/*******************************************************************************
 * Trace Recorder Library for Tracealyzer v3.3.0
 * Percepio AB, www.percepio.com
 *
 * Terms of Use
 * This file is part of the trace recorder library (RECORDER), which is the 
 * intellectual property of Percepio AB (PERCEPIO) and provided under a
 * license as follows.
 * The RECORDER may be used free of charge for the purpose of recording data
 * intended for analysis in PERCEPIO products. It may not be used or modified
 * for other purposes without explicit permission from PERCEPIO.
 * You may distribute the RECORDER in its original source code form, assuming
 * this text (terms of use, disclaimer, copyright notice) is unchanged. You are
 * allowed to distribute the RECORDER with minor modifications intended for
 * configuration or porting of the RECORDER, e.g., to allow using it on a 
 * specific processor, processor family or with a specific communication
 * interface. Any such modifications should be documented directly below
 * this comment block.  
 *
 * Disclaimer
 * The RECORDER is being delivered to you AS IS and PERCEPIO makes no warranty
 * as to its use or performance. PERCEPIO does not and cannot warrant the 
 * performance or results you may obtain by using the RECORDER or documentation.
 * PERCEPIO make no warranties, express or implied, as to noninfringement of
 * third party rights, merchantability, or fitness for any particular purpose.
 * In no event will PERCEPIO, its technology partners, or distributors be liable
 * to you for any consequential, incidental or special damages, including any
 * lost profits or lost savings, even if a representative of PERCEPIO has been
 * advised of the possibility of such damages, or for any claim by any third
 * party. Some jurisdictions do not allow the exclusion or limitation of
 * incidental, consequential or special damages, or the exclusion of implied
 * warranties or limitations on how long an implied warranty may last, so the
 * above limitations may not apply to you.
 *
 * FreeRTOS-specific definitions needed by the trace recorder
 *
 * <LICENSE INFO>
 *
 * Tabs are used for indent in this file (1 tab = 4 spaces)
 *
 * Copyright Percepio AB, 2017.
 * www.percepio.com
 ******************************************************************************/

 
#ifndef TRC_KERNEL_PORT_H
#define TRC_KERNEL_PORT_H

#include "FreeRTOS.h" /* Defines configUSE_TRACE_FACILITY */
#include "trcPortDefines.h"

#ifdef __cplusplus
extern "C" {
#endif

#define TRC_USE_TRACEALYZER_RECORDER configUSE_TRACE_FACILITY

/*** FreeRTOS version codes **************************************************/
#define FREERTOS_VERSION_NOT_SET 0
#define TRC_FREERTOS_VERSION_7_3 1 /* v7.3 is earliest supported.*/
#define TRC_FREERTOS_VERSION_7_4 2
#define TRC_FREERTOS_VERSION_7_5_OR_7_6 3
#define TRC_FREERTOS_VERSION_8_X 4 /* Any v8.x.x*/
#define TRC_FREERTOS_VERSION_9_0_0 5
#define TRC_FREERTOS_VERSION_9_0_1 6
#define TRC_FREERTOS_VERSION_9_0_2 7
#define TRC_FREERTOS_VERSION_10_0_0 8 /* If using FreeRTOS v10.0.0 or later version */

#define TRC_FREERTOS_VERSION_9_X 42 /* Not allowed anymore */

#if (TRC_CFG_FREERTOS_VERSION == TRC_FREERTOS_VERSION_9_X)
/* This setting for TRC_CFG_FREERTOS_VERSION is no longer allowed as v9.0.1 needs special handling. */
#error "Please specify your exact FreeRTOS version in trcConfig.h, from the options listed above."
#endif

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0)
#define prvGetStreamBufferType(x) (((StreamBuffer_t *)x)->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER)
#else
#define prvGetStreamBufferType(x) 0
#endif

/* Added mainly for our internal testing. This makes it easier to create test applications that
   runs on multiple FreeRTOS versions. */
#if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_8_X)
/* FreeRTOS v7.0 and later */
#define STRING_CAST(x) ((signed char *)x)
#define TickType portTickType
#else
/* FreeRTOS v8.0 and later */
#define STRING_CAST(x) x
#define TickType TickType_t
#endif

#if (defined(TRC_USE_TRACEALYZER_RECORDER)) && (TRC_USE_TRACEALYZER_RECORDER == 1)

/*******************************************************************************
 * INCLUDE_xTaskGetCurrentTaskHandle must be set to 1 for tracing to work properly
 ******************************************************************************/
#undef INCLUDE_xTaskGetCurrentTaskHandle
#define INCLUDE_xTaskGetCurrentTaskHandle 1

#ifndef TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS
#define TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS 0
#endif

#ifndef TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS
#define TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS 0
#endif

#ifndef TRC_CFG_INCLUDE_TIMER_EVENTS
#define TRC_CFG_INCLUDE_TIMER_EVENTS 0
#endif

/*******************************************************************************
 * vTraceSetQueueName(void* object, const char* name)
 *
 * Parameter object: pointer to the Queue that shall be named
 * Parameter name: the name to set (const string literal)
 *
 * Sets a name for Queue objects for display in Tracealyzer.
 ******************************************************************************/
void vTraceSetQueueName(void *object, const char *name);

/*******************************************************************************
 * vTraceSetSemaphoreName(void* object, const char* name)
 *
 * Parameter object: pointer to the Semaphore that shall be named
 * Parameter name: the name to set (const string literal)
 *
 * Sets a name for Semaphore objects for display in Tracealyzer.
 ******************************************************************************/
void vTraceSetSemaphoreName(void *object, const char *name);

/*******************************************************************************
 * vTraceSetMutexName(void* object, const char* name)
 *
 * Parameter object: pointer to the Mutex that shall be named
 * Parameter name: the name to set (const string literal)
 *
 * Sets a name for Semaphore objects for display in Tracealyzer.
 ******************************************************************************/
void vTraceSetMutexName(void *object, const char *name);

/*******************************************************************************
* vTraceSetEventGroupName(void* object, const char* name)
*
* Parameter object: pointer to the EventGroup that shall be named
* Parameter name: the name to set (const string literal)
*
* Sets a name for EventGroup objects for display in Tracealyzer.
******************************************************************************/
void vTraceSetEventGroupName(void *object, const char *name);

/*******************************************************************************
* vTraceSetStreamBufferName(void* object, const char* name)
*
* Parameter object: pointer to the StreamBuffer that shall be named
* Parameter name: the name to set (const string literal)
*
* Sets a name for StreamBuffer objects for display in Tracealyzer.
******************************************************************************/
void vTraceSetStreamBufferName(void *object, const char *name);

/*******************************************************************************
 * vTraceSetMessageBufferName(void* object, const char* name)
 *
 * Parameter object: pointer to the MessageBuffer that shall be named
 * Parameter name: the name to set (const string literal)
 *
 * Sets a name for MessageBuffer objects for display in Tracealyzer.
 ******************************************************************************/
void vTraceSetMessageBufferName(void *object, const char *name);

/*******************************************************************************
 * Note: Setting names for event groups is difficult to support, this has been
 * excluded intentionally. This since we don't know if event_groups.c is
 * included in the build, so referencing it from the recorder may cause errors.
 ******************************************************************************/

/* Gives the currently executing task (wrapper for RTOS-specific function) */
void *prvTraceGetCurrentTaskHandle(void);

#if (((TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT) && (TRC_CFG_INCLUDE_ISR_TRACING == 1))                     \
     || (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING))
/* Tells if the scheduler currently is suspended (task-switches can't occur) */
unsigned char prvTraceIsSchedulerSuspended(void);

/*******************************************************************************
 * INCLUDE_xTaskGetSchedulerState must be set to 1 for tracing to work properly
 ******************************************************************************/
#undef INCLUDE_xTaskGetSchedulerState
#define INCLUDE_xTaskGetSchedulerState 1

#endif /* (((TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT) && (TRC_CFG_INCLUDE_ISR_TRACING == 1)) ||            \
          (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING)) */

#define TRACE_KERNEL_VERSION 0x1AA1
#define TRACE_TICK_RATE_HZ configTICK_RATE_HZ /* Defined in "FreeRTOS.h" */
#define TRACE_CPU_CLOCK_HZ configCPU_CLOCK_HZ /* Defined in "FreeRTOSConfig.h" */
#define TRACE_GET_CURRENT_TASK() prvTraceGetCurrentTaskHandle()

#define TRACE_GET_OS_TICKS() (uiTraceTickCount) /* Streaming only */

/* If using dynamic allocation of snapshot trace buffer... */
#define TRACE_MALLOC(size) pvPortMalloc(size)

#ifdef configUSE_TIMERS
#if (configUSE_TIMERS == 1)
#undef INCLUDE_xTimerGetTimerDaemonTaskHandle
#define INCLUDE_xTimerGetTimerDaemonTaskHandle 1
#endif /* configUSE_TIMERS == 1*/
#endif /* configUSE_TIMERS */

/* For ARM Cortex-M devices - assumes the ARM CMSIS API is available */
#if (defined(__CORTEX_M))
#define TRACE_ALLOC_CRITICAL_SECTION() uint32_t __irq_status;
#define TRACE_ENTER_CRITICAL_SECTION()                                                                                 \
	{                                                                                                                  \
		__irq_status = __get_PRIMASK();                                                                                \
		__set_PRIMASK(1);                                                                                              \
	} /* PRIMASK disables ALL interrupts - allows for tracing in any ISR */
#define TRACE_EXIT_CRITICAL_SECTION()                                                                                  \
	{                                                                                                                  \
		__set_PRIMASK(__irq_status);                                                                                   \
	}
#endif

#if ((TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_ARM_CORTEX_A9)                                                        \
     || (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_Renesas_RX600)                                                     \
     || (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_MICROCHIP_PIC24_PIC32)                                             \
     || (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_Altera_NiosII))
#define TRACE_ALLOC_CRITICAL_SECTION() int __irq_status;
#define TRACE_ENTER_CRITICAL_SECTION()                                                                                 \
	{                                                                                                                  \
		__irq_status = portSET_INTERRUPT_MASK_FROM_ISR();                                                              \
	}
#define TRACE_EXIT_CRITICAL_SECTION()                                                                                  \
	{                                                                                                                  \
		portCLEAR_INTERRUPT_MASK_FROM_ISR(__irq_status);                                                               \
	}
#endif

#if (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_Win32)
/* In the Win32 port, there are no real interrupts, so we can use the normal critical sections */
#define TRACE_ALLOC_CRITICAL_SECTION()
#define TRACE_ENTER_CRITICAL_SECTION() portENTER_CRITICAL()
#define TRACE_EXIT_CRITICAL_SECTION() portEXIT_CRITICAL()
#endif

#if (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_POWERPC_Z4)
#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X)
/* FreeRTOS v8.0 or later */
#define TRACE_ALLOC_CRITICAL_SECTION() UBaseType_t __irq_status;
#define TRACE_ENTER_CRITICAL_SECTION()                                                                                 \
	{                                                                                                                  \
		__irq_status = portSET_INTERRUPT_MASK_FROM_ISR();                                                              \
	}
#define TRACE_EXIT_CRITICAL_SECTION()                                                                                  \
	{                                                                                                                  \
		portCLEAR_INTERRUPT_MASK_FROM_ISR(__irq_status);                                                               \
	}
#else
/* FreeRTOS v7.x */
#define TRACE_ALLOC_CRITICAL_SECTION() unsigned portBASE_TYPE __irq_status;
#define TRACE_ENTER_CRITICAL_SECTION()                                                                                 \
	{                                                                                                                  \
		__irq_status = portSET_INTERRUPT_MASK_FROM_ISR();                                                              \
	}
#define TRACE_EXIT_CRITICAL_SECTION()                                                                                  \
	{                                                                                                                  \
		portCLEAR_INTERRUPT_MASK_FROM_ISR(__irq_status);                                                               \
	}
#endif
#endif

#ifndef TRACE_ENTER_CRITICAL_SECTION
#error                                                                                                                 \
    "This hardware port has no definition for critical sections! See http://percepio.com/2014/10/27/how-to-define-critical-sections-for-the-recorder/"
#endif

#if (TRC_CFG_FREERTOS_VERSION == TRC_FREERTOS_VERSION_9_0_1)
/******************************************************************************
* Fix for FreeRTOS v9.0.1 to correctly identify xQueuePeek events.
*
* In FreeRTOS v9.0.1, the below trace hooks are incorrectly used from three
* different functions. This as the earlier function xQueueGenericReceive
* has been replaced by xQueuePeek, xQueueSemaphoreTake and xQueueReceive.
*
* xQueueGenericReceive had a parameter "xJustPeeking", used by the trace hooks
* to tell between xQueuePeek events and others. This is no longer present, so
* we need another way to correctly identify peek events. Since all three
* functions call the same trace macros, the context of these macro is unknown.
*
* We therefore check the __LINE__ macro inside of the trace macros. This gives
* the line number of queue.c, where the macros are used. This can be used to
* tell if the context is xQueuePeek or another function.
* __LINE__ is a standard compiler feature since ancient times, so it should
* work on all common compilers.
*
* This might seem as a quite brittle and unusual solution, but works in this
* particular case and is only for FreeRTOS v9.0.1.
* Future versions of FreeRTOS should not need this fix, as we have submitted
* a correction of queue.c with individual trace macros for each function.
******************************************************************************/
#define isQueueReceiveHookActuallyPeek (__LINE__ > 1674) /* Half way between the closes trace points */

#elif (TRC_CFG_FREERTOS_VERSION <= TRC_FREERTOS_VERSION_9_0_0)
#define isQueueReceiveHookActuallyPeek xJustPeeking

#elif (TRC_CFG_FREERTOS_VERSION > TRC_FREERTOS_VERSION_9_0_1)
#define isQueueReceiveHookActuallyPeek (__LINE__ < 0) /* instead of pdFALSE to fix a warning of "constant condition"   \
                                                         */

#endif

extern uint16_t CurrentFilterMask;

extern uint16_t CurrentFilterGroup;

uint8_t prvTraceGetQueueType(void *handle);

uint16_t prvTraceGetTaskNumberLow16(void *handle);
uint16_t prvTraceGetTaskNumberHigh16(void *handle);
void prvTraceSetTaskNumberLow16(void *handle, uint16_t value);
void prvTraceSetTaskNumberHigh16(void *handle, uint16_t value);

uint16_t prvTraceGetQueueNumberLow16(void *handle);
uint16_t prvTraceGetQueueNumberHigh16(void *handle);
void prvTraceSetQueueNumberLow16(void *handle, uint16_t value);
void prvTraceSetQueueNumberHigh16(void *handle, uint16_t value);

uint16_t prvTraceGetTimerNumberLow16(void *handle);
uint16_t prvTraceGetTimerNumberHigh16(void *handle);
void prvTraceSetTimerNumberLow16(void *handle, uint16_t value);
void prvTraceSetTimerNumberHigh16(void *handle, uint16_t value);

uint16_t prvTraceGetEventGroupNumberLow16(void *handle);
uint16_t prvTraceGetEventGroupNumberHigh16(void *handle);
void prvTraceSetEventGroupNumberLow16(void *handle, uint16_t value);
void prvTraceSetEventGroupNumberHigh16(void *handle, uint16_t value);

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0)
uint16_t prvTraceGetStreamBufferNumberLow16(void *handle);
uint16_t prvTraceGetStreamBufferNumberHigh16(void *handle);
void prvTraceSetStreamBufferNumberLow16(void *handle, uint16_t value);
void prvTraceSetStreamBufferNumberHigh16(void *handle, uint16_t value);
#endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */

#define TRACE_GET_TASK_FILTER(pxTask) prvTraceGetTaskNumberHigh16((void *)pxTask)
#define TRACE_SET_TASK_FILTER(pxTask, group) prvTraceSetTaskNumberHigh16((void *)pxTask, group)

#define TRACE_GET_QUEUE_FILTER(pxObject) prvTraceGetQueueNumberHigh16((void *)pxObject)
#define TRACE_SET_QUEUE_FILTER(pxObject, group) prvTraceSetQueueNumberHigh16((void *)pxObject, group)

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0)
#define TRACE_GET_EVENTGROUP_FILTER(pxObject) prvTraceGetEventGroupNumberHigh16((void *)pxObject)
#define TRACE_SET_EVENTGROUP_FILTER(pxObject, group) prvTraceSetEventGroupNumberHigh16((void *)pxObject, group)
#else /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */
/* FreeRTOS versions before v10.0 does not support filtering for event groups */
#define TRACE_GET_EVENTGROUP_FILTER(pxObject) 1
#define TRACE_SET_EVENTGROUP_FILTER(pxObject, group)
#endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0)
#define TRACE_GET_TIMER_FILTER(pxObject) prvTraceGetTimerNumberHigh16((void *)pxObject)
#define TRACE_SET_TIMER_FILTER(pxObject, group) prvTraceSetTimerNumberHigh16((void *)pxObject, group)
#else /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */
/* FreeRTOS versions before v10.0 does not support filtering for timers */
#define TRACE_GET_TIMER_FILTER(pxObject) 1
#define TRACE_SET_TIMER_FILTER(pxObject, group)
#endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */

#define TRACE_GET_STREAMBUFFER_FILTER(pxObject) prvTraceGetStreamBufferNumberHigh16((void *)pxObject)
#define TRACE_SET_STREAMBUFFER_FILTER(pxObject, group) prvTraceSetStreamBufferNumberHigh16((void *)pxObject, group)

#define TRACE_GET_OBJECT_FILTER(CLASS, pxObject) TRACE_GET_##CLASS##_FILTER(pxObject)
#define TRACE_SET_OBJECT_FILTER(CLASS, pxObject, group) TRACE_SET_##CLASS##_FILTER(pxObject, group)

/******************************************************************************/
/*** Definitions for Snapshot mode ********************************************/
/******************************************************************************/
#if (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT)

/*** The object classes *******************************************************/

#define TRACE_NCLASSES 9
#define TRACE_CLASS_QUEUE ((traceObjectClass)0)
#define TRACE_CLASS_SEMAPHORE ((traceObjectClass)1)
#define TRACE_CLASS_MUTEX ((traceObjectClass)2)
#define TRACE_CLASS_TASK ((traceObjectClass)3)
#define TRACE_CLASS_ISR ((traceObjectClass)4)
#define TRACE_CLASS_TIMER ((traceObjectClass)5)
#define TRACE_CLASS_EVENTGROUP ((traceObjectClass)6)
#define TRACE_CLASS_STREAMBUFFER ((traceObjectClass)7)
#define TRACE_CLASS_MESSAGEBUFFER ((traceObjectClass)8)

/*** Definitions for Object Table ********************************************/
#define TRACE_KERNEL_OBJECT_COUNT                                                                                      \
	(TRC_CFG_NQUEUE + TRC_CFG_NSEMAPHORE + TRC_CFG_NMUTEX + TRC_CFG_NTASK + TRC_CFG_NISR + TRC_CFG_NTIMER              \
	 + TRC_CFG_NEVENTGROUP                                                                                             \
	 + TRC_CFG_NSTREAMBUFFER                                                                                           \
	 + TRC_CFG_NMESSAGEBUFFER)

/* Queue properties (except name):	current number of message in queue */
#define PropertyTableSizeQueue (TRC_CFG_NAME_LEN_QUEUE + 1)

/* Semaphore properties (except name): state (signaled = 1, cleared = 0) */
#define PropertyTableSizeSemaphore (TRC_CFG_NAME_LEN_SEMAPHORE + 1)

/* Mutex properties (except name):	owner (task handle, 0 = free) */
#define PropertyTableSizeMutex (TRC_CFG_NAME_LEN_MUTEX + 1)

/* Task properties (except name):	Byte 0: Current priority
                                    Byte 1: state (if already active)
                                    Byte 2: legacy, not used
                                    Byte 3: legacy, not used */
#define PropertyTableSizeTask (TRC_CFG_NAME_LEN_TASK + 4)

/* ISR properties:					Byte 0: priority
                                    Byte 1: state (if already active) */
#define PropertyTableSizeISR (TRC_CFG_NAME_LEN_ISR + 2)

/* TRC_CFG_NTIMER properties:				Byte 0: state (unused for now) */
#define PropertyTableSizeTimer (TRC_CFG_NAME_LEN_TIMER + 1)

/* TRC_CFG_NEVENTGROUP properties:			Byte 0-3: state (unused for now)*/
#define PropertyTableSizeEventGroup (TRC_CFG_NAME_LEN_EVENTGROUP + 4)

/* TRC_CFG_NSTREAMBUFFER properties:			Byte 0-3: state (unused for now)*/
#define PropertyTableSizeStreamBuffer (TRC_CFG_NAME_LEN_STREAMBUFFER + 4)

/* TRC_CFG_NMESSAGEBUFFER properties:			Byte 0-3: state (unused for now)*/
#define PropertyTableSizeMessageBuffer (TRC_CFG_NAME_LEN_MESSAGEBUFFER + 4)

/* The layout of the byte array representing the Object Property Table */
#define StartIndexQueue 0
#define StartIndexSemaphore StartIndexQueue + TRC_CFG_NQUEUE *                  PropertyTableSizeQueue
#define StartIndexMutex StartIndexSemaphore + TRC_CFG_NSEMAPHORE *              PropertyTableSizeSemaphore
#define StartIndexTask StartIndexMutex + TRC_CFG_NMUTEX *                       PropertyTableSizeMutex
#define StartIndexISR StartIndexTask + TRC_CFG_NTASK *                          PropertyTableSizeTask
#define StartIndexTimer StartIndexISR + TRC_CFG_NISR *                          PropertyTableSizeISR
#define StartIndexEventGroup StartIndexTimer + TRC_CFG_NTIMER *                 PropertyTableSizeTimer
#define StartIndexStreamBuffer StartIndexEventGroup + TRC_CFG_NEVENTGROUP *     PropertyTableSizeEventGroup
#define StartIndexMessageBuffer StartIndexStreamBuffer + TRC_CFG_NSTREAMBUFFER *PropertyTableSizeStreamBuffer

/* Number of bytes used by the object table */
#define TRACE_OBJECT_TABLE_SIZE StartIndexMessageBuffer + TRC_CFG_NMESSAGEBUFFER *PropertyTableSizeMessageBuffer

/* Flag to tell the context of tracePEND_FUNC_CALL_FROM_ISR */
extern int uiInEventGroupSetBitsFromISR;

/* Initialization of the object property table */
void vTraceInitObjectPropertyTable(void);

/* Initialization of the handle mechanism, see e.g, prvTraceGetObjectHandle */
void vTraceInitObjectHandleStack(void);

/* Returns the "Not enough handles" error message for the specified object class */
const char *pszTraceGetErrorNotEnoughHandles(traceObjectClass objectclass);

void *prvTraceGetCurrentTaskHandle(void);

/******************************************************************************
 * TraceQueueClassTable
 * Translates a FreeRTOS QueueType into trace objects classes (TRACE_CLASS_).
 * Has one entry for each QueueType, gives TRACE_CLASS ID.
 ******************************************************************************/
extern traceObjectClass TraceQueueClassTable[5];

/*** Event codes for snapshot mode - must match Tracealyzer config files ******/

#define NULL_EVENT (0x00UL)

/*******************************************************************************
 * EVENTGROUP_DIV
 *
 * Miscellaneous events.
 ******************************************************************************/
#define EVENTGROUP_DIV (NULL_EVENT + 1UL)     /*0x01*/
#define DIV_XPS (EVENTGROUP_DIV + 0UL)        /*0x01*/
#define DIV_TASK_READY (EVENTGROUP_DIV + 1UL) /*0x02*/
#define DIV_NEW_TIME (EVENTGROUP_DIV + 2UL)   /*0x03*/

/*******************************************************************************
 * EVENTGROUP_TS
 *
 * Events for storing task-switches and interrupts. The RESUME events are
 * generated if the task/interrupt is already marked active.
 ******************************************************************************/
#define EVENTGROUP_TS (EVENTGROUP_DIV + 3UL) /*0x04*/
#define TS_ISR_BEGIN (EVENTGROUP_TS + 0UL)   /*0x04*/
#define TS_ISR_RESUME (EVENTGROUP_TS + 1UL)  /*0x05*/
#define TS_TASK_BEGIN (EVENTGROUP_TS + 2UL)  /*0x06*/
#define TS_TASK_RESUME (EVENTGROUP_TS + 3UL) /*0x07*/

/*******************************************************************************
 * EVENTGROUP_OBJCLOSE_NAME
 *
 * About Close Events
 * When an object is evicted from the object property table (object close), two
 * internal events are stored (EVENTGROUP_OBJCLOSE_NAME and
 * EVENTGROUP_OBJCLOSE_PROP), containing the handle-name mapping and object
 * properties valid up to this point.
 ******************************************************************************/
#define EVENTGROUP_OBJCLOSE_NAME_SUCCESS (EVENTGROUP_TS + 4UL) /*0x08*/

/*******************************************************************************
 * EVENTGROUP_OBJCLOSE_PROP
 *
 * The internal event carrying properties of deleted objects
 * The handle and object class of the closed object is not stored in this event,
 * but is assumed to be the same as in the preceding CLOSE event. Thus, these
 * two events must be generated from within a critical section.
 * When queues are closed, arg1 is the "state" property (i.e., number of
 * buffered messages/signals).
 * When actors are closed, arg1 is priority, arg2 is handle of the "instance
 * finish" event, and arg3 is event code of the "instance finish" event.
 * In this case, the lower three bits is the object class of the instance finish
 * handle. The lower three bits are not used (always zero) when queues are
 * closed since the queue type is given in the previous OBJCLOSE_NAME event.
 ******************************************************************************/
#define EVENTGROUP_OBJCLOSE_PROP_SUCCESS (EVENTGROUP_OBJCLOSE_NAME_SUCCESS + 8UL) /*0x10*/

/*******************************************************************************
 * EVENTGROUP_CREATE
 *
 * The events in this group are used to log Kernel object creations.
 * The lower three bits in the event code gives the object class, i.e., type of
 * create operation (task, queue, semaphore, etc).
 ******************************************************************************/
#define EVENTGROUP_CREATE_OBJ_SUCCESS (EVENTGROUP_OBJCLOSE_PROP_SUCCESS + 8UL) /*0x18*/

/*******************************************************************************
 * EVENTGROUP_SEND
 *
 * The events in this group are used to log Send/Give events on queues,
 * semaphores and mutexes The lower three bits in the event code gives the
 * object class, i.e., what type of object that is operated on (queue, semaphore
 * or mutex).
 ******************************************************************************/
#define EVENTGROUP_SEND_SUCCESS (EVENTGROUP_CREATE_OBJ_SUCCESS + 8UL) /*0x20*/

/*******************************************************************************
 * EVENTGROUP_RECEIVE
 *
 * The events in this group are used to log Receive/Take events on queues,
 * semaphores and mutexes. The lower three bits in the event code gives the
 * object class, i.e., what type of object that is operated on (queue, semaphore
 * or mutex).
 ******************************************************************************/
#define EVENTGROUP_RECEIVE_SUCCESS (EVENTGROUP_SEND_SUCCESS + 8UL) /*0x28*/

/* Send/Give operations, from ISR */
#define EVENTGROUP_SEND_FROM_ISR_SUCCESS (EVENTGROUP_RECEIVE_SUCCESS + 8UL) /*0x30*/

/* Receive/Take operations, from ISR */
#define EVENTGROUP_RECEIVE_FROM_ISR_SUCCESS (EVENTGROUP_SEND_FROM_ISR_SUCCESS + 8UL) /*0x38*/

/* "Failed" event type versions of above (timeout, failed allocation, etc) */
#define EVENTGROUP_KSE_FAILED (EVENTGROUP_RECEIVE_FROM_ISR_SUCCESS + 8UL) /*0x40*/

/* Failed create calls - memory allocation failed */
#define EVENTGROUP_CREATE_OBJ_FAILED (EVENTGROUP_KSE_FAILED) /*0x40*/

/* Failed send/give - timeout! */
#define EVENTGROUP_SEND_FAILED (EVENTGROUP_CREATE_OBJ_FAILED + 8UL) /*0x48*/

/* Failed receive/take - timeout! */
#define EVENTGROUP_RECEIVE_FAILED (EVENTGROUP_SEND_FAILED + 8UL) /*0x50*/

/* Failed non-blocking send/give - queue full */
#define EVENTGROUP_SEND_FROM_ISR_FAILED (EVENTGROUP_RECEIVE_FAILED + 8UL) /*0x58*/

/* Failed non-blocking receive/take - queue empty */
#define EVENTGROUP_RECEIVE_FROM_ISR_FAILED (EVENTGROUP_SEND_FROM_ISR_FAILED + 8UL) /*0x60*/

/* Events when blocking on receive/take */
#define EVENTGROUP_RECEIVE_BLOCK (EVENTGROUP_RECEIVE_FROM_ISR_FAILED + 8UL) /*0x68*/

/* Events when blocking on send/give */
#define EVENTGROUP_SEND_BLOCK (EVENTGROUP_RECEIVE_BLOCK + 8UL) /*0x70*/

/* Events on queue peek (receive) */
#define EVENTGROUP_PEEK_SUCCESS (EVENTGROUP_SEND_BLOCK + 8UL) /*0x78*/

/* Events on object delete (vTaskDelete or vQueueDelete) */
#define EVENTGROUP_DELETE_OBJ_SUCCESS (EVENTGROUP_PEEK_SUCCESS + 8UL) /*0x80*/

/* Other events - object class is implied: TASK */
#define EVENTGROUP_OTHERS (EVENTGROUP_DELETE_OBJ_SUCCESS + 8UL) /*0x88*/
#define TASK_DELAY_UNTIL (EVENTGROUP_OTHERS + 0UL)              /*0x88*/
#define TASK_DELAY (EVENTGROUP_OTHERS + 1UL)                    /*0x89*/
#define TASK_SUSPEND (EVENTGROUP_OTHERS + 2UL)                  /*0x8A*/
#define TASK_RESUME (EVENTGROUP_OTHERS + 3UL)                   /*0x8B*/
#define TASK_RESUME_FROM_ISR (EVENTGROUP_OTHERS + 4UL)          /*0x8C*/
#define TASK_PRIORITY_SET (EVENTGROUP_OTHERS + 5UL)             /*0x8D*/
#define TASK_PRIORITY_INHERIT (EVENTGROUP_OTHERS + 6UL)         /*0x8E*/
#define TASK_PRIORITY_DISINHERIT (EVENTGROUP_OTHERS + 7UL)      /*0x8F*/

#define EVENTGROUP_MISC_PLACEHOLDER (EVENTGROUP_OTHERS + 8UL)              /*0x90*/
#define PEND_FUNC_CALL (EVENTGROUP_MISC_PLACEHOLDER + 0UL)                 /*0x90*/
#define PEND_FUNC_CALL_FROM_ISR (EVENTGROUP_MISC_PLACEHOLDER + 1UL)        /*0x91*/
#define PEND_FUNC_CALL_FAILED (EVENTGROUP_MISC_PLACEHOLDER + 2UL)          /*0x92*/
#define PEND_FUNC_CALL_FROM_ISR_FAILED (EVENTGROUP_MISC_PLACEHOLDER + 3UL) /*0x93*/
#define MEM_MALLOC_SIZE (EVENTGROUP_MISC_PLACEHOLDER + 4UL)                /*0x94*/
#define MEM_MALLOC_ADDR (EVENTGROUP_MISC_PLACEHOLDER + 5UL)                /*0x95*/
#define MEM_FREE_SIZE (EVENTGROUP_MISC_PLACEHOLDER + 6UL)                  /*0x96*/
#define MEM_FREE_ADDR (EVENTGROUP_MISC_PLACEHOLDER + 7UL)                  /*0x97*/

/* User events */
#define EVENTGROUP_USEREVENT (EVENTGROUP_MISC_PLACEHOLDER + 8UL) /*0x98*/
#define USER_EVENT (EVENTGROUP_USEREVENT + 0UL)

/* Allow for 0-15 arguments (the number of args is added to event code) */
#define USER_EVENT_LAST (EVENTGROUP_USEREVENT + 15UL) /*0xA7*/

/*******************************************************************************
 * XTS Event - eXtended TimeStamp events
 * The timestamps used in the recorder are "differential timestamps" (DTS), i.e.
 * the time since the last stored event. The DTS fields are either 1 or 2 bytes
 * in the other events, depending on the bytes available in the event struct.
 * If the time since the last event (the DTS) is larger than allowed for by
 * the DTS field of the current event, an XTS event is inserted immediately
 * before the original event. The XTS event contains up to 3 additional bytes
 * of the DTS value - the higher bytes of the true DTS value. The lower 1-2
 * bytes are stored in the normal DTS field.
 * There are two types of XTS events, XTS8 and XTS16. An XTS8 event is stored
 * when there is only room for 1 byte (8 bit) DTS data in the original event,
 * which means a limit of 0xFF (255UL). The XTS16 is used when the original event
 * has a 16 bit DTS field and thereby can handle values up to 0xFFFF (65535UL).
 *
 * Using a very high frequency time base can result in many XTS events.
 * Preferably, the time between two OS ticks should fit in 16 bits, i.e.,
 * at most 65535. If your time base has a higher frequency, you can define
 * the TRACE
 ******************************************************************************/

#define EVENTGROUP_SYS (EVENTGROUP_USEREVENT + 16UL) /*0xA8*/
#define XTS8 (EVENTGROUP_SYS + 0UL)                  /*0xA8*/
#define XTS16 (EVENTGROUP_SYS + 1UL)                 /*0xA9*/
#define EVENT_BEING_WRITTEN (EVENTGROUP_SYS + 2UL)   /*0xAA*/
#define RESERVED_DUMMY_CODE (EVENTGROUP_SYS + 3UL)   /*0xAB*/
#define LOW_POWER_BEGIN (EVENTGROUP_SYS + 4UL)       /*0xAC*/
#define LOW_POWER_END (EVENTGROUP_SYS + 5UL)         /*0xAD*/
#define XID (EVENTGROUP_SYS + 6UL)                   /*0xAE*/
#define XTS16L (EVENTGROUP_SYS + 7UL)                /*0xAF*/

#define EVENTGROUP_TIMER (EVENTGROUP_SYS + 8UL)       /*0xB0*/
#define TIMER_CREATE (EVENTGROUP_TIMER + 0UL)         /*0xB0*/
#define TIMER_START (EVENTGROUP_TIMER + 1UL)          /*0xB1*/
#define TIMER_RST (EVENTGROUP_TIMER + 2UL)            /*0xB2*/
#define TIMER_STOP (EVENTGROUP_TIMER + 3UL)           /*0xB3*/
#define TIMER_CHANGE_PERIOD (EVENTGROUP_TIMER + 4UL)  /*0xB4*/
#define TIMER_DELETE_OBJ (EVENTGROUP_TIMER + 5UL)     /*0xB5*/
#define TIMER_START_FROM_ISR (EVENTGROUP_TIMER + 6UL) /*0xB6*/
#define TIMER_RESET_FROM_ISR (EVENTGROUP_TIMER + 7UL) /*0xB7*/
#define TIMER_STOP_FROM_ISR (EVENTGROUP_TIMER + 8UL)  /*0xB8*/

#define TIMER_CREATE_FAILED (EVENTGROUP_TIMER + 9UL)          /*0xB9*/
#define TIMER_START_FAILED (EVENTGROUP_TIMER + 10UL)          /*0xBA*/
#define TIMER_RESET_FAILED (EVENTGROUP_TIMER + 11UL)          /*0xBB*/
#define TIMER_STOP_FAILED (EVENTGROUP_TIMER + 12UL)           /*0xBC*/
#define TIMER_CHANGE_PERIOD_FAILED (EVENTGROUP_TIMER + 13UL)  /*0xBD*/
#define TIMER_DELETE_FAILED (EVENTGROUP_TIMER + 14UL)         /*0xBE*/
#define TIMER_START_FROM_ISR_FAILED (EVENTGROUP_TIMER + 15UL) /*0xBF*/
#define TIMER_RESET_FROM_ISR_FAILED (EVENTGROUP_TIMER + 16UL) /*0xC0*/
#define TIMER_STOP_FROM_ISR_FAILED (EVENTGROUP_TIMER + 17UL)  /*0xC1*/

#define EVENTGROUP_EG (EVENTGROUP_TIMER + 18UL)                     /*0xC2*/
#define EVENT_GROUP_CREATE (EVENTGROUP_EG + 0UL)                    /*0xC2*/
#define EVENT_GROUP_CREATE_FAILED (EVENTGROUP_EG + 1UL)             /*0xC3*/
#define EVENT_GROUP_SYNC_BLOCK (EVENTGROUP_EG + 2UL)                /*0xC4*/
#define EVENT_GROUP_SYNC_END (EVENTGROUP_EG + 3UL)                  /*0xC5*/
#define EVENT_GROUP_WAIT_BITS_BLOCK (EVENTGROUP_EG + 4UL)           /*0xC6*/
#define EVENT_GROUP_WAIT_BITS_END (EVENTGROUP_EG + 5UL)             /*0xC7*/
#define EVENT_GROUP_CLEAR_BITS (EVENTGROUP_EG + 6UL)                /*0xC8*/
#define EVENT_GROUP_CLEAR_BITS_FROM_ISR (EVENTGROUP_EG + 7UL)       /*0xC9*/
#define EVENT_GROUP_SET_BITS (EVENTGROUP_EG + 8UL)                  /*0xCA*/
#define EVENT_GROUP_DELETE_OBJ (EVENTGROUP_EG + 9UL)                /*0xCB*/
#define EVENT_GROUP_SYNC_END_FAILED (EVENTGROUP_EG + 10UL)          /*0xCC*/
#define EVENT_GROUP_WAIT_BITS_END_FAILED (EVENTGROUP_EG + 11UL)     /*0xCD*/
#define EVENT_GROUP_SET_BITS_FROM_ISR (EVENTGROUP_EG + 12UL)        /*0xCE*/
#define EVENT_GROUP_SET_BITS_FROM_ISR_FAILED (EVENTGROUP_EG + 13UL) /*0xCF*/

#define TASK_INSTANCE_FINISHED_NEXT_KSE (EVENTGROUP_EG + 14UL) /*0xD0*/
#define TASK_INSTANCE_FINISHED_DIRECT (EVENTGROUP_EG + 15UL)   /*0xD1*/

#define TRACE_TASK_NOTIFY_GROUP (EVENTGROUP_EG + 16UL)                  /*0xD2*/
#define TRACE_TASK_NOTIFY (TRACE_TASK_NOTIFY_GROUP + 0UL)               /*0xD2*/
#define TRACE_TASK_NOTIFY_TAKE (TRACE_TASK_NOTIFY_GROUP + 1UL)          /*0xD3*/
#define TRACE_TASK_NOTIFY_TAKE_BLOCK (TRACE_TASK_NOTIFY_GROUP + 2UL)    /*0xD4*/
#define TRACE_TASK_NOTIFY_TAKE_FAILED (TRACE_TASK_NOTIFY_GROUP + 3UL)   /*0xD5*/
#define TRACE_TASK_NOTIFY_WAIT (TRACE_TASK_NOTIFY_GROUP + 4UL)          /*0xD6*/
#define TRACE_TASK_NOTIFY_WAIT_BLOCK (TRACE_TASK_NOTIFY_GROUP + 5UL)    /*0xD7*/
#define TRACE_TASK_NOTIFY_WAIT_FAILED (TRACE_TASK_NOTIFY_GROUP + 6UL)   /*0xD8*/
#define TRACE_TASK_NOTIFY_FROM_ISR (TRACE_TASK_NOTIFY_GROUP + 7UL)      /*0xD9*/
#define TRACE_TASK_NOTIFY_GIVE_FROM_ISR (TRACE_TASK_NOTIFY_GROUP + 8UL) /*0xDA*/

#define TIMER_EXPIRED (TRACE_TASK_NOTIFY_GROUP + 9UL) /* 0xDB */

/* Events on queue peek (receive) */
#define EVENTGROUP_PEEK_BLOCK (TRACE_TASK_NOTIFY_GROUP + 10UL) /*0xDC*/
/* peek block on queue:			0xDC	*/
/* peek block on semaphore:		0xDD	*/
/* peek block on mutex:			0xDE	*/

/* Events on queue peek (receive) */
#define EVENTGROUP_PEEK_FAILED (EVENTGROUP_PEEK_BLOCK + 3UL) /*0xDF*/
/* peek failed on queue:		0xDF	*/
/* peek failed on semaphore:	0xE0	*/
/* peek failed on mutex:		0xE1	*/

#define EVENTGROUP_STREAMBUFFER_DIV (EVENTGROUP_PEEK_FAILED + 3UL)                    /*0xE2*/
#define TRACE_STREAMBUFFER_RESET (EVENTGROUP_STREAMBUFFER_DIV + 0)                    /*0xE2*/
#define TRACE_MESSAGEBUFFER_RESET (EVENTGROUP_STREAMBUFFER_DIV + 1UL)                 /*0xE3*/
#define TRACE_STREAMBUFFER_OBJCLOSE_NAME_SUCCESS (EVENTGROUP_STREAMBUFFER_DIV + 2UL)  /*0xE4*/
#define TRACE_MESSAGEBUFFER_OBJCLOSE_NAME_SUCCESS (EVENTGROUP_STREAMBUFFER_DIV + 3UL) /*0xE5*/
#define TRACE_STREAMBUFFER_OBJCLOSE_PROP_SUCCESS (EVENTGROUP_STREAMBUFFER_DIV + 4UL)  /*0xE6*/
#define TRACE_MESSAGEBUFFER_OBJCLOSE_PROP_SUCCESS (EVENTGROUP_STREAMBUFFER_DIV + 5UL) /*0xE7*/

/* The following are using previously "lost" event codes */
#define TRACE_STREAMBUFFER_CREATE_OBJ_SUCCESS (EVENTGROUP_CREATE_OBJ_SUCCESS + 4UL)             /*0x1C*/
#define TRACE_STREAMBUFFER_CREATE_OBJ_FAILED (EVENTGROUP_CREATE_OBJ_FAILED + 4UL)               /*0x44*/
#define TRACE_STREAMBUFFER_DELETE_OBJ_SUCCESS (EVENTGROUP_DELETE_OBJ_SUCCESS + 4UL)             /*0x84*/
#define TRACE_STREAMBUFFER_SEND_SUCCESS (EVENTGROUP_SEND_SUCCESS + 3UL)                         /*0x23*/
#define TRACE_STREAMBUFFER_SEND_BLOCK (EVENTGROUP_SEND_BLOCK + 3UL)                             /*0x73*/
#define TRACE_STREAMBUFFER_SEND_FAILED (EVENTGROUP_SEND_FAILED + 3UL)                           /*0x4B*/
#define TRACE_STREAMBUFFER_RECEIVE_SUCCESS (EVENTGROUP_RECEIVE_SUCCESS + 3UL)                   /*0x2B*/
#define TRACE_STREAMBUFFER_RECEIVE_BLOCK (EVENTGROUP_RECEIVE_BLOCK + 3UL)                       /*0x6B*/
#define TRACE_STREAMBUFFER_RECEIVE_FAILED (EVENTGROUP_RECEIVE_FAILED + 3UL)                     /*0x53*/
#define TRACE_STREAMBUFFER_SEND_FROM_ISR_SUCCESS (EVENTGROUP_SEND_FROM_ISR_SUCCESS + 3UL)       /*0x33*/
#define TRACE_STREAMBUFFER_SEND_FROM_ISR_FAILED (EVENTGROUP_SEND_FROM_ISR_FAILED + 3UL)         /*0x5B*/
#define TRACE_STREAMBUFFER_RECEIVE_FROM_ISR_SUCCESS (EVENTGROUP_RECEIVE_FROM_ISR_SUCCESS + 3UL) /*0x3B*/
#define TRACE_STREAMBUFFER_RECEIVE_FROM_ISR_FAILED (EVENTGROUP_RECEIVE_FROM_ISR_FAILED + 3UL)   /*0x63*/

/* The following are using previously "lost" event codes. These macros aren't even directly referenced, instead we do
 * (equivalent STREAMBUFFER code) + 1. */
#define TRACE_MESSAGEBUFFER_CREATE_OBJ_SUCCESS (EVENTGROUP_CREATE_OBJ_SUCCESS + 5UL)             /*0x1D*/
#define TRACE_MESSAGEBUFFER_CREATE_OBJ_FAILED (EVENTGROUP_CREATE_OBJ_FAILED + 5UL)               /*0x45*/
#define TRACE_MESSAGEBUFFER_DELETE_OBJ_SUCCESS (EVENTGROUP_DELETE_OBJ_SUCCESS + 5UL)             /*0x85*/
#define TRACE_MESSAGEBUFFER_SEND_SUCCESS (EVENTGROUP_SEND_SUCCESS + 4UL)                         /*0x24*/
#define TRACE_MESSAGEBUFFER_SEND_BLOCK (EVENTGROUP_SEND_BLOCK + 4UL)                             /*0x74*/
#define TRACE_MESSAGEBUFFER_SEND_FAILED (EVENTGROUP_SEND_FAILED + 4UL)                           /*0x4C*/
#define TRACE_MESSAGEBUFFER_RECEIVE_SUCCESS (EVENTGROUP_RECEIVE_SUCCESS + 4UL)                   /*0x2C*/
#define TRACE_MESSAGEBUFFER_RECEIVE_BLOCK (EVENTGROUP_RECEIVE_BLOCK + 4UL)                       /*0x6C*/
#define TRACE_MESSAGEBUFFER_RECEIVE_FAILED (EVENTGROUP_RECEIVE_FAILED + 4UL)                     /*0x54*/
#define TRACE_MESSAGEBUFFER_SEND_FROM_ISR_SUCCESS (EVENTGROUP_SEND_FROM_ISR_SUCCESS + 4UL)       /*0x34*/
#define TRACE_MESSAGEBUFFER_SEND_FROM_ISR_FAILED (EVENTGROUP_SEND_FROM_ISR_FAILED + 4UL)         /*0x5C*/
#define TRACE_MESSAGEBUFFER_RECEIVE_FROM_ISR_SUCCESS (EVENTGROUP_RECEIVE_FROM_ISR_SUCCESS + 4UL) /*0x3C*/
#define TRACE_MESSAGEBUFFER_RECEIVE_FROM_ISR_FAILED (EVENTGROUP_RECEIVE_FROM_ISR_FAILED + 4UL)   /*0x64*/

/* LAST EVENT (0xE7) */

/****************************
* MACROS TO GET TRACE CLASS *
****************************/
#define TRACE_GET_TRACE_CLASS_FROM_TASK_CLASS(kernelClass) (TRACE_CLASS_TASK)
#define TRACE_GET_TRACE_CLASS_FROM_TASK_OBJECT(pxObject) (TRACE_CLASS_TASK)

#define TRACE_GET_TRACE_CLASS_FROM_QUEUE_CLASS(kernelClass) TraceQueueClassTable[kernelClass]
#define TRACE_GET_TRACE_CLASS_FROM_QUEUE_OBJECT(pxObject)                                                              \
	TRACE_GET_TRACE_CLASS_FROM_QUEUE_CLASS(prvTraceGetQueueType(pxObject))

#define TRACE_GET_TRACE_CLASS_FROM_TIMER_CLASS(kernelClass) (TRACE_CLASS_TIMER)
#define TRACE_GET_TRACE_CLASS_FROM_TIMER_OBJECT(pxObject) (TRACE_CLASS_TIMER)

#define TRACE_GET_TRACE_CLASS_FROM_EVENTGROUP_CLASS(kernelClass) (TRACE_CLASS_EVENTGROUP)
#define TRACE_GET_TRACE_CLASS_FROM_EVENTGROUP_OBJECT(pxObject) (TRACE_CLASS_EVENTGROUP)

/* TRACE_GET_TRACE_CLASS_FROM_STREAMBUFFER_CLASS can only be accessed with a parameter indicating if it is a
 * MessageBuffer */
#define TRACE_GET_TRACE_CLASS_FROM_STREAMBUFFER_CLASS(xIsMessageBuffer)                                                \
	(xIsMessageBuffer == 1 ? TRACE_CLASS_MESSAGEBUFFER : TRACE_CLASS_STREAMBUFFER)
#define TRACE_GET_TRACE_CLASS_FROM_STREAMBUFFER_OBJECT(pxObject)                                                       \
	(prvGetStreamBufferType(pxObject) == 1 ? TRACE_CLASS_MESSAGEBUFFER : TRACE_CLASS_STREAMBUFFER)

/* Generic versions */
#define TRACE_GET_CLASS_TRACE_CLASS(CLASS, kernelClass) TRACE_GET_TRACE_CLASS_FROM_##CLASS##_CLASS(kernelClass)
#define TRACE_GET_OBJECT_TRACE_CLASS(CLASS, pxObject) TRACE_GET_TRACE_CLASS_FROM_##CLASS##_OBJECT(pxObject)

/******************************
* MACROS TO GET OBJECT NUMBER *
******************************/
#define TRACE_GET_TASK_NUMBER(pxTCB) (traceHandle)(prvTraceGetTaskNumberLow16(pxTCB))
#define TRACE_SET_TASK_NUMBER(pxTCB)                                                                                   \
	prvTraceSetTaskNumberLow16(pxTCB, prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(TASK, pxTCB)));

#define TRACE_GET_QUEUE_NUMBER(queue) ((traceHandle)prvTraceGetQueueNumberLow16(queue))
#define TRACE_SET_QUEUE_NUMBER(queue)                                                                                  \
	prvTraceSetQueueNumberLow16(queue, (uint16_t)prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, queue)));

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0)
#define TRACE_GET_TIMER_NUMBER(tmr) ((traceHandle)prvTraceGetTimerNumberLow16(tmr))
#define TRACE_SET_TIMER_NUMBER(tmr)                                                                                    \
	prvTraceSetTimerNumberLow16(tmr, (uint16_t)prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(TIMER, tmr)));
#else /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */
#define TRACE_GET_TIMER_NUMBER(tmr) ((traceHandle)((Timer_t *)tmr)->uxTimerNumber)
#define TRACE_SET_TIMER_NUMBER(tmr)                                                                                    \
	((Timer_t *)tmr)->uxTimerNumber = prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(TIMER, tmr));
#endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0)
#define TRACE_GET_EVENTGROUP_NUMBER(eg) ((traceHandle)prvTraceGetEventGroupNumberLow16(eg))
#define TRACE_SET_EVENTGROUP_NUMBER(eg)                                                                                \
	prvTraceSetEventGroupNumberLow16(eg,                                                                               \
	                                 (uint16_t)prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(EVENTGROUP, eg)));
#else /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */
#define TRACE_GET_EVENTGROUP_NUMBER(eg) ((traceHandle)uxEventGroupGetNumber(eg))
#define TRACE_SET_EVENTGROUP_NUMBER(eg)                                                                                \
	((EventGroup_t *)eg)->uxEventGroupNumber = prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(EVENTGROUP, eg));
#endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_10_0_0) */

#define TRACE_GET_STREAMBUFFER_NUMBER(sb) ((traceHandle)prvTraceGetStreamBufferNumberLow16(sb))
#define TRACE_SET_STREAMBUFFER_NUMBER(sb)                                                                              \
	prvTraceSetStreamBufferNumberLow16(                                                                                \
	    sb, (uint16_t)prvTraceGetObjectHandle(TRACE_GET_OBJECT_TRACE_CLASS(STREAMBUFFER, sb)));

/* Generic versions */
#define TRACE_GET_OBJECT_NUMBER(CLASS, pxObject) TRACE_GET_##CLASS##_NUMBER(pxObject)
#define TRACE_SET_OBJECT_NUMBER(CLASS, pxObject) TRACE_SET_##CLASS##_NUMBER(pxObject)

/******************************
* MACROS TO GET EVENT CODES   *
******************************/
#define TRACE_GET_TASK_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass)                                                  \
	(uint8_t)(EVENTGROUP_##SERVICE##_##RESULT + TRACE_GET_CLASS_TRACE_CLASS(TASK, kernelClass))
#define TRACE_GET_QUEUE_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass)                                                 \
	(uint8_t)(EVENTGROUP_##SERVICE##_##RESULT + TRACE_GET_CLASS_TRACE_CLASS(QUEUE, kernelClass))
#define TRACE_GET_TIMER_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass) --THIS IS NOT USED--
#define TRACE_GET_EVENTGROUP_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass) --THIS IS NOT USED--
#define TRACE_GET_STREAMBUFFER_CLASS_EVENT_CODE(SERVICE, RESULT, isMessageBuffer)                                      \
	(uint8_t)(TRACE_STREAMBUFFER_##SERVICE##_##RESULT + (uint8_t)isMessageBuffer)

#define TRACE_GET_TASK_OBJECT_EVENT_CODE(SERVICE, RESULT, pxTCB)                                                       \
	(uint8_t)(EVENTGROUP_##SERVICE##_##RESULT + TRACE_CLASS_TASK)
#define TRACE_GET_QUEUE_OBJECT_EVENT_CODE(SERVICE, RESULT, pxObject)                                                   \
	(uint8_t)(EVENTGROUP_##SERVICE##_##RESULT + TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxObject))
#define TRACE_GET_TIMER_OBJECT_EVENT_CODE(SERVICE, RESULT, UNUSED) --THIS IS NOT USED--
#define TRACE_GET_EVENTGROUP_OBJECT_EVENT_CODE(SERVICE, RESULT, UNUSED) --THIS IS NOT USED--
#define TRACE_GET_STREAMBUFFER_OBJECT_EVENT_CODE(SERVICE, RESULT, pxObject)                                            \
	(uint8_t)(TRACE_STREAMBUFFER_##SERVICE##_##RESULT + prvGetStreamBufferType(pxObject))

/* Generic versions */
#define TRACE_GET_CLASS_EVENT_CODE(SERVICE, RESULT, CLASS, kernelClass)                                                \
	TRACE_GET_##CLASS##_CLASS_EVENT_CODE(SERVICE, RESULT, kernelClass)
#define TRACE_GET_OBJECT_EVENT_CODE(SERVICE, RESULT, CLASS, pxObject)                                                  \
	TRACE_GET_##CLASS##_OBJECT_EVENT_CODE(SERVICE, RESULT, pxObject)

/******************************
* SPECIAL MACROS FOR TASKS    *
******************************/
#define TRACE_GET_TASK_PRIORITY(pxTCB) ((uint8_t)pxTCB->uxPriority)
#define TRACE_GET_TASK_NAME(pxTCB) ((char *)pxTCB->pcTaskName)

/*** The trace macros for snapshot mode **************************************/

#if defined(configUSE_TICKLESS_IDLE)
#if (configUSE_TICKLESS_IDLE != 0)

#undef traceLOW_POWER_IDLE_BEGIN
#define traceLOW_POWER_IDLE_BEGIN()                                                                                    \
	{                                                                                                                  \
		extern uint32_t trace_disable_timestamp;                                                                       \
		prvTraceStoreLowPower(0);                                                                                      \
		trace_disable_timestamp = 1;                                                                                   \
	}

#undef traceLOW_POWER_IDLE_END
#define traceLOW_POWER_IDLE_END()                                                                                      \
	{                                                                                                                  \
		extern uint32_t trace_disable_timestamp;                                                                       \
		trace_disable_timestamp = 0;                                                                                   \
		prvTraceStoreLowPower(1);                                                                                      \
	}

#endif /* configUSE_TICKLESS_IDLE != 0 */
#endif /* configUSE_TICKLESS_IDLE  */

/* A macro that will update the tick count when returning from tickless idle */
#undef traceINCREASE_TICK_COUNT
#define traceINCREASE_TICK_COUNT(xCount)

/* Called for each task that becomes ready */
#undef traceMOVED_TASK_TO_READY_STATE
#define traceMOVED_TASK_TO_READY_STATE(pxTCB) trcKERNEL_HOOKS_MOVED_TASK_TO_READY_STATE(pxTCB);

/* Called on each OS tick. Will call uiPortGetTimestamp to make sure it is called at least once every OS tick. */
#undef traceTASK_INCREMENT_TICK

#if (TRC_CFG_FREERTOS_VERSION <= TRC_FREERTOS_VERSION_7_4)

#define traceTASK_INCREMENT_TICK(xTickCount)                                                                           \
	if (uxSchedulerSuspended == (unsigned portBASE_TYPE)pdTRUE || uxMissedTicks == 0) {                                \
		trcKERNEL_HOOKS_INCREMENT_TICK();                                                                              \
	}                                                                                                                  \
	if (uxSchedulerSuspended == (unsigned portBASE_TYPE)pdFALSE) {                                                     \
		trcKERNEL_HOOKS_NEW_TIME(DIV_NEW_TIME, xTickCount + 1);                                                        \
	}

#else

#define traceTASK_INCREMENT_TICK(xTickCount)                                                                           \
	if (uxSchedulerSuspended == (unsigned portBASE_TYPE)pdTRUE || uxPendedTicks == 0) {                                \
		trcKERNEL_HOOKS_INCREMENT_TICK();                                                                              \
	}                                                                                                                  \
	if (uxSchedulerSuspended == (unsigned portBASE_TYPE)pdFALSE) {                                                     \
		trcKERNEL_HOOKS_NEW_TIME(DIV_NEW_TIME, xTickCount + 1);                                                        \
	}

#endif

/* Called on each task-switch */
#undef traceTASK_SWITCHED_IN
#define traceTASK_SWITCHED_IN() trcKERNEL_HOOKS_TASK_SWITCH(TRACE_GET_CURRENT_TASK());

/* Called on vTaskSuspend */
#undef traceTASK_SUSPEND
#define traceTASK_SUSPEND(pxTaskToSuspend) trcKERNEL_HOOKS_TASK_SUSPEND(TASK_SUSPEND, pxTaskToSuspend);

/* Called from special case with timer only */
#undef traceTASK_DELAY_SUSPEND
#define traceTASK_DELAY_SUSPEND(pxTaskToSuspend)                                                                       \
	trcKERNEL_HOOKS_TASK_SUSPEND(TASK_SUSPEND, pxTaskToSuspend);                                                       \
	trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED();

/* Called on vTaskDelay - note the use of FreeRTOS variable xTicksToDelay */
#undef traceTASK_DELAY
#define traceTASK_DELAY()                                                                                              \
	trcKERNEL_HOOKS_TASK_DELAY(TASK_DELAY, pxCurrentTCB, xTicksToDelay);                                               \
	trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED();

/* Called on vTaskDelayUntil - note the use of FreeRTOS variable xTimeToWake */
#undef traceTASK_DELAY_UNTIL
#if TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0
#define traceTASK_DELAY_UNTIL(xTimeToWake)                                                                             \
	trcKERNEL_HOOKS_TASK_DELAY(TASK_DELAY_UNTIL, pxCurrentTCB, xTimeToWake);                                           \
	trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED();
#else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */
#define traceTASK_DELAY_UNTIL()                                                                                        \
	trcKERNEL_HOOKS_TASK_DELAY(TASK_DELAY_UNTIL, pxCurrentTCB, xTimeToWake);                                           \
	trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED();
#endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */

/* Called on vTaskCreate */
#undef traceTASK_CREATE
#define traceTASK_CREATE(pxNewTCB)                                                                                     \
	if (pxNewTCB != NULL) {                                                                                            \
		trcKERNEL_HOOKS_TASK_CREATE(TRACE_GET_OBJECT_EVENT_CODE(CREATE_OBJ, SUCCESS, TASK, pxNewTCB), TASK, pxNewTCB); \
	}

/* Called in vTaskCreate, if it fails (typically if the stack can not be allocated) */
#undef traceTASK_CREATE_FAILED
#define traceTASK_CREATE_FAILED()                                                                                      \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(                                                            \
	    TRACE_GET_CLASS_EVENT_CODE(CREATE_OBJ, FAILED, TASK, NOT_USED), 0);

/* Called on vTaskDelete */
#undef traceTASK_DELETE
#define traceTASK_DELETE(pxTaskToDelete)                                                                               \
	{                                                                                                                  \
		TRACE_ALLOC_CRITICAL_SECTION();                                                                                \
		TRACE_ENTER_CRITICAL_SECTION();                                                                                \
		trcKERNEL_HOOKS_TASK_DELETE(TRACE_GET_OBJECT_EVENT_CODE(DELETE_OBJ, SUCCESS, TASK, pxTaskToDelete),            \
		                            TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_NAME, SUCCESS, TASK, pxTaskToDelete),         \
		                            TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_PROP, SUCCESS, TASK, pxTaskToDelete),         \
		                            pxTaskToDelete);                                                                   \
		TRACE_EXIT_CRITICAL_SECTION();                                                                                 \
	}

/* Called in xQueueCreate, and thereby for all other object based on queues, such as semaphores. */
#undef traceQUEUE_CREATE
#define traceQUEUE_CREATE(pxNewQueue)                                                                                  \
	trcKERNEL_HOOKS_OBJECT_CREATE(                                                                                     \
	    TRACE_GET_OBJECT_EVENT_CODE(CREATE_OBJ, SUCCESS, QUEUE, pxNewQueue), QUEUE, pxNewQueue);

/* Called in xQueueCreate, if the queue creation fails */
#undef traceQUEUE_CREATE_FAILED
#define traceQUEUE_CREATE_FAILED(queueType)                                                                            \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(                                                            \
	    TRACE_GET_CLASS_EVENT_CODE(CREATE_OBJ, FAILED, QUEUE, queueType), 0);

/* Called on vQueueDelete */
#undef traceQUEUE_DELETE
#define traceQUEUE_DELETE(pxQueue)                                                                                     \
	{                                                                                                                  \
		TRACE_ALLOC_CRITICAL_SECTION();                                                                                \
		TRACE_ENTER_CRITICAL_SECTION();                                                                                \
		trcKERNEL_HOOKS_OBJECT_DELETE(TRACE_GET_OBJECT_EVENT_CODE(DELETE_OBJ, SUCCESS, QUEUE, pxQueue),                \
		                              TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_NAME, SUCCESS, QUEUE, pxQueue),             \
		                              TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_PROP, SUCCESS, QUEUE, pxQueue),             \
		                              QUEUE,                                                                           \
		                              pxQueue);                                                                        \
		TRACE_EXIT_CRITICAL_SECTION();                                                                                 \
	}

/* This macro is not necessary as of FreeRTOS v9.0.0 */
#if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0)
/* Called in xQueueCreateMutex, and thereby also from xSemaphoreCreateMutex and xSemaphoreCreateRecursiveMutex */
#undef traceCREATE_MUTEX
#define traceCREATE_MUTEX(pxNewQueue)                                                                                  \
	trcKERNEL_HOOKS_OBJECT_CREATE(                                                                                     \
	    TRACE_GET_OBJECT_EVENT_CODE(CREATE_OBJ, SUCCESS, QUEUE, pxNewQueue), QUEUE, pxNewQueue);

/* Called in xQueueCreateMutex when the operation fails (when memory allocation fails) */
#undef traceCREATE_MUTEX_FAILED
#define traceCREATE_MUTEX_FAILED()                                                                                     \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(                                                            \
	    TRACE_GET_CLASS_EVENT_CODE(CREATE_OBJ, FAILED, QUEUE, queueQUEUE_TYPE_MUTEX), 0);
#endif /* (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) */

/* Called when the Mutex can not be given, since not holder */
#undef traceGIVE_MUTEX_RECURSIVE_FAILED
#define traceGIVE_MUTEX_RECURSIVE_FAILED(pxMutex)                                                                      \
	trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, FAILED, QUEUE, pxMutex), QUEUE, pxMutex);

/* Called when a message is sent to a queue */ /* CS IS NEW ! */
#undef traceQUEUE_SEND
#define traceQUEUE_SEND(pxQueue)                                                                                       \
	trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, SUCCESS, QUEUE, pxQueue), QUEUE, pxQueue);        \
	trcKERNEL_HOOKS_SET_OBJECT_STATE(QUEUE,                                                                            \
	                                 pxQueue,                                                                          \
	                                 TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxQueue) == TRACE_CLASS_MUTEX                 \
	                                     ? (uint8_t)0                                                                  \
	                                     : (uint8_t)(pxQueue->uxMessagesWaiting + 1));

/* Called when a message failed to be sent to a queue (timeout) */
#undef traceQUEUE_SEND_FAILED
#define traceQUEUE_SEND_FAILED(pxQueue)                                                                                \
	trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, FAILED, QUEUE, pxQueue), QUEUE, pxQueue);

/* Called when the task is blocked due to a send operation on a full queue */
#undef traceBLOCKING_ON_QUEUE_SEND
#define traceBLOCKING_ON_QUEUE_SEND(pxQueue)                                                                           \
	trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND, BLOCK, QUEUE, pxQueue), QUEUE, pxQueue);

/* Called when a message is received from a queue */
#undef traceQUEUE_RECEIVE
#define traceQUEUE_RECEIVE(pxQueue)                                                                                    \
	if (isQueueReceiveHookActuallyPeek) {                                                                              \
		trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, SUCCESS, QUEUE, pxQueue), QUEUE, pxQueue);    \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, SUCCESS, QUEUE, pxQueue), QUEUE, pxQueue); \
	}                                                                                                                  \
	trcKERNEL_HOOKS_SET_OBJECT_STATE(QUEUE,                                                                            \
	                                 pxQueue,                                                                          \
	                                 TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxQueue) == TRACE_CLASS_MUTEX                 \
	                                     ? (uint8_t)TRACE_GET_TASK_NUMBER(TRACE_GET_CURRENT_TASK())                    \
	                                     : (uint8_t)(pxQueue->uxMessagesWaiting - 1));

/* Called when a receive operation on a queue fails (timeout) */
#undef traceQUEUE_RECEIVE_FAILED
#define traceQUEUE_RECEIVE_FAILED(pxQueue)                                                                             \
	if (isQueueReceiveHookActuallyPeek) {                                                                              \
		trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, FAILED, QUEUE, pxQueue), QUEUE, pxQueue);     \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, FAILED, QUEUE, pxQueue), QUEUE, pxQueue);  \
	}

/* Called when the task is blocked due to a receive operation on an empty queue */
#undef traceBLOCKING_ON_QUEUE_RECEIVE
#define traceBLOCKING_ON_QUEUE_RECEIVE(pxQueue)                                                                        \
	if (isQueueReceiveHookActuallyPeek) {                                                                              \
		trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, BLOCK, QUEUE, pxQueue), QUEUE, pxQueue);      \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, BLOCK, QUEUE, pxQueue), QUEUE, pxQueue);   \
	}                                                                                                                  \
	if (TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxQueue) != TRACE_CLASS_MUTEX) {                                           \
		trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED();                                                                  \
	}

/* Called on xQueuePeek */
#undef traceQUEUE_PEEK
#define traceQUEUE_PEEK(pxQueue)                                                                                       \
	trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, SUCCESS, QUEUE, pxQueue), QUEUE, pxQueue);

/* Called on xQueuePeek fail/timeout (added in FreeRTOS v9.0.2) */
#undef traceQUEUE_PEEK_FAILED
#define traceQUEUE_PEEK_FAILED(pxQueue)                                                                                \
	trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, FAILED, QUEUE, pxQueue), QUEUE, pxQueue);

/* Called on xQueuePeek blocking (added in FreeRTOS v9.0.2) */
#undef traceBLOCKING_ON_QUEUE_PEEK
#define traceBLOCKING_ON_QUEUE_PEEK(pxQueue)                                                                           \
	trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(PEEK, BLOCK, QUEUE, pxQueue), QUEUE, pxQueue);          \
	if (TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, pxQueue) != TRACE_CLASS_MUTEX) {                                           \
		trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED();                                                                  \
	}

/* Called when a message is sent from interrupt context, e.g., using xQueueSendFromISR */
#undef traceQUEUE_SEND_FROM_ISR
#define traceQUEUE_SEND_FROM_ISR(pxQueue)                                                                              \
	trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                    \
	    TRACE_GET_OBJECT_EVENT_CODE(SEND_FROM_ISR, SUCCESS, QUEUE, pxQueue), QUEUE, pxQueue);                          \
	trcKERNEL_HOOKS_SET_OBJECT_STATE(QUEUE, pxQueue, (uint8_t)(pxQueue->uxMessagesWaiting + 1));

/* Called when a message send from interrupt context fails (since the queue was full) */
#undef traceQUEUE_SEND_FROM_ISR_FAILED
#define traceQUEUE_SEND_FROM_ISR_FAILED(pxQueue)                                                                       \
	trcKERNEL_HOOKS_KERNEL_SERVICE(TRACE_GET_OBJECT_EVENT_CODE(SEND_FROM_ISR, FAILED, QUEUE, pxQueue), QUEUE, pxQueue);

/* Called when a message is received in interrupt context, e.g., using xQueueReceiveFromISR */
#undef traceQUEUE_RECEIVE_FROM_ISR
#define traceQUEUE_RECEIVE_FROM_ISR(pxQueue)                                                                           \
	trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                    \
	    TRACE_GET_OBJECT_EVENT_CODE(RECEIVE_FROM_ISR, SUCCESS, QUEUE, pxQueue), QUEUE, pxQueue);                       \
	trcKERNEL_HOOKS_SET_OBJECT_STATE(QUEUE, pxQueue, (uint8_t)(pxQueue->uxMessagesWaiting - 1));

/* Called when a message receive from interrupt context fails (since the queue was empty) */
#undef traceQUEUE_RECEIVE_FROM_ISR_FAILED
#define traceQUEUE_RECEIVE_FROM_ISR_FAILED(pxQueue)                                                                    \
	trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                    \
	    TRACE_GET_OBJECT_EVENT_CODE(RECEIVE_FROM_ISR, FAILED, QUEUE, pxQueue), QUEUE, pxQueue);

#undef traceQUEUE_REGISTRY_ADD
#define traceQUEUE_REGISTRY_ADD(object, name)                                                                          \
	prvTraceSetObjectName(TRACE_GET_OBJECT_TRACE_CLASS(QUEUE, object), TRACE_GET_OBJECT_NUMBER(QUEUE, object), name);

/* Called in vTaskPrioritySet */
#undef traceTASK_PRIORITY_SET
#define traceTASK_PRIORITY_SET(pxTask, uxNewPriority)                                                                  \
	trcKERNEL_HOOKS_TASK_PRIORITY_CHANGE(TASK_PRIORITY_SET, pxTask, uxNewPriority);

/* Called in vTaskPriorityInherit, which is called by Mutex operations */
#undef traceTASK_PRIORITY_INHERIT
#define traceTASK_PRIORITY_INHERIT(pxTask, uxNewPriority)                                                              \
	trcKERNEL_HOOKS_TASK_PRIORITY_CHANGE(TASK_PRIORITY_INHERIT, pxTask, uxNewPriority);

/* Called in vTaskPriorityDisinherit, which is called by Mutex operations */
#undef traceTASK_PRIORITY_DISINHERIT
#define traceTASK_PRIORITY_DISINHERIT(pxTask, uxNewPriority)                                                           \
	trcKERNEL_HOOKS_TASK_PRIORITY_CHANGE(TASK_PRIORITY_DISINHERIT, pxTask, uxNewPriority);

/* Called in vTaskResume */
#undef traceTASK_RESUME
#define traceTASK_RESUME(pxTaskToResume) trcKERNEL_HOOKS_TASK_RESUME(TASK_RESUME, pxTaskToResume);

/* Called in vTaskResumeFromISR */
#undef traceTASK_RESUME_FROM_ISR
#define traceTASK_RESUME_FROM_ISR(pxTaskToResume) trcKERNEL_HOOKS_TASK_RESUME(TASK_RESUME_FROM_ISR, pxTaskToResume);

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X)

#if (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1)

extern void vTraceStoreMemMangEvent(uint32_t ecode, uint32_t address, int32_t size);

/* MALLOC and FREE are always stored, no matter if they happen inside filtered task */
#undef traceMALLOC
#define traceMALLOC(pvAddress, uiSize)                                                                                 \
	{                                                                                                                  \
		if (pvAddress != 0)                                                                                            \
			vTraceStoreMemMangEvent(MEM_MALLOC_SIZE, (uint32_t)pvAddress, (int32_t)uiSize);                            \
	}

#undef traceFREE
#define traceFREE(pvAddress, uiSize)                                                                                   \
	{                                                                                                                  \
		vTraceStoreMemMangEvent(MEM_FREE_SIZE, (uint32_t)pvAddress, -((int32_t)uiSize));                               \
	}

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1) */

#if (TRC_CFG_SCHEDULING_ONLY == 0 && TRC_CFG_INCLUDE_TIMER_EVENTS == 1)

/* Called in timer.c - xTimerCreate */
#undef traceTIMER_CREATE
#define traceTIMER_CREATE(tmr) trcKERNEL_HOOKS_OBJECT_CREATE(TIMER_CREATE, TIMER, tmr);

#undef traceTIMER_CREATE_FAILED
#define traceTIMER_CREATE_FAILED() trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(TIMER_CREATE_FAILED, 0);

/* Note that xCommandID can never be tmrCOMMAND_EXECUTE_CALLBACK (-1) since the trace macro is not called in that case
 */
#undef traceTIMER_COMMAND_SEND
#define traceTIMER_COMMAND_SEND(tmr, xCommandID, xOptionalValue, xReturn)                                              \
	if (xCommandID > tmrCOMMAND_START_DONT_TRACE) {                                                                    \
		if (xCommandID == tmrCOMMAND_CHANGE_PERIOD) {                                                                  \
			if (xReturn == pdPASS) {                                                                                   \
				trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TIMER_CHANGE_PERIOD, TIMER, tmr, xOptionalValue);            \
			} else {                                                                                                   \
				trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TIMER_CHANGE_PERIOD_FAILED, TIMER, tmr, xOptionalValue);     \
			}                                                                                                          \
		} else if ((xCommandID == tmrCOMMAND_DELETE) && (xReturn == pdPASS)) {                                         \
			trcKERNEL_HOOKS_OBJECT_DELETE(TIMER_DELETE_OBJ,                                                            \
			                              EVENTGROUP_OBJCLOSE_NAME_SUCCESS + TRACE_GET_OBJECT_TRACE_CLASS(TIMER, tmr), \
			                              EVENTGROUP_OBJCLOSE_PROP_SUCCESS + TRACE_GET_OBJECT_TRACE_CLASS(TIMER, tmr), \
			                              TIMER,                                                                       \
			                              tmr);                                                                        \
		} else {                                                                                                       \
			trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(                                                                 \
			    EVENTGROUP_TIMER + (uint32_t)xCommandID                                                                \
			        + ((xReturn == pdPASS) ? 0 : (TIMER_CREATE_FAILED - TIMER_CREATE)),                                \
			    TIMER,                                                                                                 \
			    tmr,                                                                                                   \
			    xOptionalValue);                                                                                       \
		}                                                                                                              \
	}

#undef traceTIMER_EXPIRED
#define traceTIMER_EXPIRED(tmr) trcKERNEL_HOOKS_KERNEL_SERVICE(TIMER_EXPIRED, TIMER, tmr);

#endif

#if (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS == 1)

#undef tracePEND_FUNC_CALL
#define tracePEND_FUNC_CALL(func, arg1, arg2, ret)                                                                     \
	if (ret == pdPASS) {                                                                                               \
		trcKERNEL_HOOKS_KERNEL_SERVICE(PEND_FUNC_CALL, TASK, xTimerGetTimerDaemonTaskHandle());                        \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE(PEND_FUNC_CALL_FAILED, TASK, xTimerGetTimerDaemonTaskHandle());                 \
	}

#undef tracePEND_FUNC_CALL_FROM_ISR
#define tracePEND_FUNC_CALL_FROM_ISR(func, arg1, arg2, ret)                                                            \
	if (!uiInEventGroupSetBitsFromISR) {                                                                               \
		prvTraceStoreKernelCall(                                                                                       \
		    PEND_FUNC_CALL_FROM_ISR, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(xTimerGetTimerDaemonTaskHandle()));       \
	}                                                                                                                  \
	uiInEventGroupSetBitsFromISR = 0;

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS == 1) */

#endif /* (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X) */

#if (TRC_CFG_SCHEDULING_ONLY == 0 && TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1)

#undef traceEVENT_GROUP_CREATE
#define traceEVENT_GROUP_CREATE(eg) trcKERNEL_HOOKS_OBJECT_CREATE(EVENT_GROUP_CREATE, EVENTGROUP, eg);

#undef traceEVENT_GROUP_CREATE_FAILED
#define traceEVENT_GROUP_CREATE_FAILED()                                                                               \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(EVENT_GROUP_CREATE_FAILED, 0);

#undef traceEVENT_GROUP_DELETE
#define traceEVENT_GROUP_DELETE(eg)                                                                                    \
	{                                                                                                                  \
		TRACE_ALLOC_CRITICAL_SECTION();                                                                                \
		TRACE_ENTER_CRITICAL_SECTION();                                                                                \
		trcKERNEL_HOOKS_OBJECT_DELETE(EVENT_GROUP_DELETE_OBJ,                                                          \
		                              EVENTGROUP_OBJCLOSE_NAME_SUCCESS + TRACE_GET_OBJECT_TRACE_CLASS(EVENTGROUP, eg), \
		                              EVENTGROUP_OBJCLOSE_NAME_SUCCESS + TRACE_GET_OBJECT_TRACE_CLASS(EVENTGROUP, eg), \
		                              EVENTGROUP,                                                                      \
		                              eg);                                                                             \
		TRACE_EXIT_CRITICAL_SECTION();                                                                                 \
	}

#undef traceEVENT_GROUP_SYNC_BLOCK
#define traceEVENT_GROUP_SYNC_BLOCK(eg, bitsToSet, bitsToWaitFor)                                                      \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_SYNC_BLOCK, EVENTGROUP, eg, bitsToWaitFor);

#undef traceEVENT_GROUP_SYNC_END
#define traceEVENT_GROUP_SYNC_END(eg, bitsToSet, bitsToWaitFor, wasTimeout)                                            \
	if (wasTimeout) {                                                                                                  \
		trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_SYNC_END_FAILED, EVENTGROUP, eg, bitsToWaitFor);         \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_SYNC_END, EVENTGROUP, eg, bitsToWaitFor);                \
	}

#undef traceEVENT_GROUP_WAIT_BITS_BLOCK
#define traceEVENT_GROUP_WAIT_BITS_BLOCK(eg, bitsToWaitFor)                                                            \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_WAIT_BITS_BLOCK, EVENTGROUP, eg, bitsToWaitFor);             \
	trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED();

#undef traceEVENT_GROUP_WAIT_BITS_END
#define traceEVENT_GROUP_WAIT_BITS_END(eg, bitsToWaitFor, wasTimeout)                                                  \
	if (wasTimeout) {                                                                                                  \
		trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_WAIT_BITS_END_FAILED, EVENTGROUP, eg, bitsToWaitFor);    \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_WAIT_BITS_END, EVENTGROUP, eg, bitsToWaitFor);           \
	}

#undef traceEVENT_GROUP_CLEAR_BITS
#define traceEVENT_GROUP_CLEAR_BITS(eg, bitsToClear)                                                                   \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_CLEAR_BITS, EVENTGROUP, eg, bitsToClear);

#undef traceEVENT_GROUP_CLEAR_BITS_FROM_ISR
#define traceEVENT_GROUP_CLEAR_BITS_FROM_ISR(eg, bitsToClear)                                                          \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_CLEAR_BITS_FROM_ISR, EVENTGROUP, eg, bitsToClear);

#undef traceEVENT_GROUP_SET_BITS
#define traceEVENT_GROUP_SET_BITS(eg, bitsToSet)                                                                       \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_SET_BITS, EVENTGROUP, eg, bitsToSet);

#undef traceEVENT_GROUP_SET_BITS_FROM_ISR
#define traceEVENT_GROUP_SET_BITS_FROM_ISR(eg, bitsToSet)                                                              \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(EVENT_GROUP_SET_BITS_FROM_ISR, EVENTGROUP, eg, bitsToSet);               \
	uiInEventGroupSetBitsFromISR = 1;

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0 && TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1 && TRC_CFG_FREERTOS_VERSION >=      \
          TRC_FREERTOS_VERSION_8_X) */

#if (TRC_CFG_SCHEDULING_ONLY == 0)
#undef traceTASK_NOTIFY_TAKE
#if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0)
#define traceTASK_NOTIFY_TAKE()                                                                                        \
	if (pxCurrentTCB->eNotifyState == eNotified) {                                                                     \
		trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE, TASK, pxCurrentTCB, xTicksToWait);           \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE_FAILED, TASK, pxCurrentTCB, xTicksToWait);    \
	}
#else /* TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0 */
#define traceTASK_NOTIFY_TAKE()                                                                                        \
	if (pxCurrentTCB->ucNotifyState == taskNOTIFICATION_RECEIVED) {                                                    \
		trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE, TASK, pxCurrentTCB, xTicksToWait);           \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE_FAILED, TASK, pxCurrentTCB, xTicksToWait);    \
	}
#endif /* TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0 */

#undef traceTASK_NOTIFY_TAKE_BLOCK
#define traceTASK_NOTIFY_TAKE_BLOCK()                                                                                  \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_PARAM(TRACE_TASK_NOTIFY_TAKE_BLOCK, TASK, pxCurrentTCB, xTicksToWait);         \
	trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED();

#undef traceTASK_NOTIFY_WAIT
#if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0)
#define traceTASK_NOTIFY_WAIT()                                                                                        \
	if (pxCurrentTCB->eNotifyState == eNotified) {                                                                     \
		prvTraceStoreKernelCallWithParam(                                                                              \
		    TRACE_TASK_NOTIFY_WAIT, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait);              \
	} else {                                                                                                           \
		prvTraceStoreKernelCallWithParam(                                                                              \
		    TRACE_TASK_NOTIFY_WAIT_FAILED, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait);       \
	}
#else /* TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0 */
#define traceTASK_NOTIFY_WAIT()                                                                                        \
	if (pxCurrentTCB->ucNotifyState == taskNOTIFICATION_RECEIVED) {                                                    \
		prvTraceStoreKernelCallWithParam(                                                                              \
		    TRACE_TASK_NOTIFY_WAIT, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait);              \
	} else {                                                                                                           \
		prvTraceStoreKernelCallWithParam(                                                                              \
		    TRACE_TASK_NOTIFY_WAIT_FAILED, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait);       \
	}
#endif /* TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0 */

#undef traceTASK_NOTIFY_WAIT_BLOCK
#define traceTASK_NOTIFY_WAIT_BLOCK()                                                                                  \
	prvTraceStoreKernelCallWithParam(                                                                                  \
	    TRACE_TASK_NOTIFY_WAIT_BLOCK, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(pxCurrentTCB), xTicksToWait);            \
	trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED();

#undef traceTASK_NOTIFY
#define traceTASK_NOTIFY()                                                                                             \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreKernelCall(TRACE_TASK_NOTIFY, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(xTaskToNotify));

#undef traceTASK_NOTIFY_FROM_ISR
#define traceTASK_NOTIFY_FROM_ISR()                                                                                    \
	prvTraceStoreKernelCall(TRACE_TASK_NOTIFY_FROM_ISR, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(xTaskToNotify));

#undef traceTASK_NOTIFY_GIVE_FROM_ISR
#define traceTASK_NOTIFY_GIVE_FROM_ISR()                                                                               \
	prvTraceStoreKernelCall(TRACE_TASK_NOTIFY_GIVE_FROM_ISR, TRACE_CLASS_TASK, TRACE_GET_TASK_NUMBER(xTaskToNotify));

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) */

#if (TRC_CFG_SCHEDULING_ONLY == 0)

#undef traceSTREAM_BUFFER_CREATE
#define traceSTREAM_BUFFER_CREATE(pxStreamBuffer, xIsMessageBuffer)                                                    \
	trcKERNEL_HOOKS_OBJECT_CREATE(                                                                                     \
	    TRACE_GET_OBJECT_EVENT_CODE(CREATE_OBJ, SUCCESS, STREAMBUFFER, pxStreamBuffer), STREAMBUFFER, pxStreamBuffer);

#undef traceSTREAM_BUFFER_CREATE_FAILED
#define traceSTREAM_BUFFER_CREATE_FAILED(xIsMessageBuffer)                                                             \
	trcKERNEL_HOOKS_KERNEL_SERVICE_WITH_NUMERIC_PARAM_ONLY(                                                            \
	    TRACE_GET_CLASS_EVENT_CODE(CREATE_OBJ, FAILED, STREAMBUFFER, xIsMessageBuffer), 0);

#undef traceSTREAM_BUFFER_CREATE_STATIC_FAILED
#define traceSTREAM_BUFFER_CREATE_STATIC_FAILED(xReturn, xIsMessageBuffer)                                             \
	traceSTREAM_BUFFER_CREATE_FAILED(xIsMessageBuffer)

#undef traceSTREAM_BUFFER_DELETE
#define traceSTREAM_BUFFER_DELETE(xStreamBuffer)                                                                       \
	trcKERNEL_HOOKS_OBJECT_DELETE(TRACE_GET_OBJECT_EVENT_CODE(DELETE_OBJ, SUCCESS, STREAMBUFFER, xStreamBuffer),       \
	                              TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_NAME, SUCCESS, STREAMBUFFER, xStreamBuffer),    \
	                              TRACE_GET_OBJECT_EVENT_CODE(OBJCLOSE_PROP, SUCCESS, STREAMBUFFER, xStreamBuffer),    \
	                              STREAMBUFFER,                                                                        \
	                              xStreamBuffer);

#undef traceSTREAM_BUFFER_RESET
#define traceSTREAM_BUFFER_RESET(xStreamBuffer)                                                                        \
	trcKERNEL_HOOKS_KERNEL_SERVICE(prvGetStreamBufferType(xStreamBuffer) > 0 ? TRACE_MESSAGEBUFFER_RESET               \
	                                                                         : TRACE_STREAMBUFFER_RESET,               \
	                               STREAMBUFFER,                                                                       \
	                               xStreamBuffer);                                                                     \
	trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, 0);

#undef traceSTREAM_BUFFER_SEND
#define traceSTREAM_BUFFER_SEND(xStreamBuffer, xReturn)                                                                \
	trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                    \
	    TRACE_GET_OBJECT_EVENT_CODE(SEND, SUCCESS, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer);         \
	trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, prvBytesInBuffer(xStreamBuffer));

#undef traceBLOCKING_ON_STREAM_BUFFER_SEND
#define traceBLOCKING_ON_STREAM_BUFFER_SEND(xStreamBuffer)                                                             \
	trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                    \
	    TRACE_GET_OBJECT_EVENT_CODE(SEND, BLOCK, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer);

#undef traceSTREAM_BUFFER_SEND_FAILED
#define traceSTREAM_BUFFER_SEND_FAILED(xStreamBuffer)                                                                  \
	trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                    \
	    TRACE_GET_OBJECT_EVENT_CODE(SEND, FAILED, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer);

#undef traceSTREAM_BUFFER_RECEIVE
#define traceSTREAM_BUFFER_RECEIVE(xStreamBuffer, xReceivedLength)                                                     \
	trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                    \
	    TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, SUCCESS, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer);      \
	trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, prvBytesInBuffer(xStreamBuffer));

#undef traceBLOCKING_ON_STREAM_BUFFER_RECEIVE
#define traceBLOCKING_ON_STREAM_BUFFER_RECEIVE(xStreamBuffer)                                                          \
	trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                    \
	    TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, BLOCK, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer);

#undef traceSTREAM_BUFFER_RECEIVE_FAILED
#define traceSTREAM_BUFFER_RECEIVE_FAILED(xStreamBuffer)                                                               \
	trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                    \
	    TRACE_GET_OBJECT_EVENT_CODE(RECEIVE, FAILED, STREAMBUFFER, xStreamBuffer), STREAMBUFFER, xStreamBuffer);

#undef traceSTREAM_BUFFER_SEND_FROM_ISR
#define traceSTREAM_BUFFER_SEND_FROM_ISR(xStreamBuffer, xReturn)                                                       \
	if (xReturn > (size_t)0) {                                                                                         \
		trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                \
		    TRACE_GET_OBJECT_EVENT_CODE(SEND_FROM_ISR, SUCCESS, STREAMBUFFER, xStreamBuffer),                          \
		    STREAMBUFFER,                                                                                              \
		    xStreamBuffer);                                                                                            \
		trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, prvBytesInBuffer(xStreamBuffer));                \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                \
		    TRACE_GET_OBJECT_EVENT_CODE(SEND_FROM_ISR, FAILED, STREAMBUFFER, xStreamBuffer),                           \
		    STREAMBUFFER,                                                                                              \
		    xStreamBuffer);                                                                                            \
	}

#undef traceSTREAM_BUFFER_RECEIVE_FROM_ISR
#define traceSTREAM_BUFFER_RECEIVE_FROM_ISR(xStreamBuffer, xReceivedLength)                                            \
	if (xReceivedLength > (size_t)0) {                                                                                 \
		trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                \
		    TRACE_GET_OBJECT_EVENT_CODE(RECEIVE_FROM_ISR, SUCCESS, STREAMBUFFER, xStreamBuffer),                       \
		    STREAMBUFFER,                                                                                              \
		    xStreamBuffer);                                                                                            \
		trcKERNEL_HOOKS_SET_OBJECT_STATE(STREAMBUFFER, xStreamBuffer, prvBytesInBuffer(xStreamBuffer));                \
	} else {                                                                                                           \
		trcKERNEL_HOOKS_KERNEL_SERVICE(                                                                                \
		    TRACE_GET_OBJECT_EVENT_CODE(RECEIVE_FROM_ISR, FAILED, STREAMBUFFER, xStreamBuffer),                        \
		    STREAMBUFFER,                                                                                              \
		    xStreamBuffer);                                                                                            \
	}

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) */

#endif /*#if TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT */

/******************************************************************************/
/*** Definitions for Streaming mode *******************************************/
/******************************************************************************/
#if (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING)

/*******************************************************************************
* vTraceStoreKernelObjectName
*
* Set the name for a kernel object (defined by its address).
******************************************************************************/
void vTraceStoreKernelObjectName(void *object, const char *name);

/*******************************************************************************
* prvIsNewTCB
*
* Tells if this task is already executing, or if there has been a task-switch.
* Assumed to be called within a trace hook in kernel context.
*******************************************************************************/
uint32_t prvIsNewTCB(void *pNewTCB);

#define TRACE_GET_CURRENT_TASK() prvTraceGetCurrentTaskHandle()

/*************************************************************************/
/* KERNEL SPECIFIC OBJECT CONFIGURATION									 */
/*************************************************************************/

/*******************************************************************************
 * The event codes - should match the offline config file.
 ******************************************************************************/

/*** Event codes for streaming - should match the Tracealyzer config file *****/
#define PSF_EVENT_NULL_EVENT 0x00

#define PSF_EVENT_TRACE_START 0x01
#define PSF_EVENT_TS_CONFIG 0x02
#define PSF_EVENT_OBJ_NAME 0x03
#define PSF_EVENT_TASK_PRIORITY 0x04
#define PSF_EVENT_TASK_PRIO_INHERIT 0x05
#define PSF_EVENT_TASK_PRIO_DISINHERIT 0x06
#define PSF_EVENT_DEFINE_ISR 0x07

#define PSF_EVENT_TASK_CREATE 0x10
#define PSF_EVENT_QUEUE_CREATE 0x11
#define PSF_EVENT_SEMAPHORE_BINARY_CREATE 0x12
#define PSF_EVENT_MUTEX_CREATE 0x13
#define PSF_EVENT_TIMER_CREATE 0x14
#define PSF_EVENT_EVENTGROUP_CREATE 0x15
#define PSF_EVENT_SEMAPHORE_COUNTING_CREATE 0x16
#define PSF_EVENT_MUTEX_RECURSIVE_CREATE 0x17
#define PSF_EVENT_STREAMBUFFER_CREATE 0x18
#define PSF_EVENT_MESSAGEBUFFER_CREATE 0x19

#define PSF_EVENT_TASK_DELETE 0x20
#define PSF_EVENT_QUEUE_DELETE 0x21
#define PSF_EVENT_SEMAPHORE_DELETE 0x22
#define PSF_EVENT_MUTEX_DELETE 0x23
#define PSF_EVENT_TIMER_DELETE 0x24
#define PSF_EVENT_EVENTGROUP_DELETE 0x25
#define PSF_EVENT_STREAMBUFFER_DELETE 0x28
#define PSF_EVENT_MESSAGEBUFFER_DELETE 0x29

#define PSF_EVENT_TASK_READY 0x30
#define PSF_EVENT_NEW_TIME 0x31
#define PSF_EVENT_NEW_TIME_SCHEDULER_SUSPENDED 0x32
#define PSF_EVENT_ISR_BEGIN 0x33
#define PSF_EVENT_ISR_RESUME 0x34
#define PSF_EVENT_TS_BEGIN 0x35
#define PSF_EVENT_TS_RESUME 0x36
#define PSF_EVENT_TASK_ACTIVATE 0x37

#define PSF_EVENT_MALLOC 0x38
#define PSF_EVENT_FREE 0x39

#define PSF_EVENT_LOWPOWER_BEGIN 0x3A
#define PSF_EVENT_LOWPOWER_END 0x3B

#define PSF_EVENT_IFE_NEXT 0x3C
#define PSF_EVENT_IFE_DIRECT 0x3D

#define PSF_EVENT_TASK_CREATE_FAILED 0x40
#define PSF_EVENT_QUEUE_CREATE_FAILED 0x41
#define PSF_EVENT_SEMAPHORE_BINARY_CREATE_FAILED 0x42
#define PSF_EVENT_MUTEX_CREATE_FAILED 0x43
#define PSF_EVENT_TIMER_CREATE_FAILED 0x44
#define PSF_EVENT_EVENTGROUP_CREATE_FAILED 0x45
#define PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED 0x46
#define PSF_EVENT_MUTEX_RECURSIVE_CREATE_FAILED 0x47
#define PSF_EVENT_STREAMBUFFER_CREATE_FAILED 0x49
#define PSF_EVENT_MESSAGEBUFFER_CREATE_FAILED 0x4A

#define PSF_EVENT_TIMER_DELETE_FAILED 0x48

#define PSF_EVENT_QUEUE_SEND 0x50
#define PSF_EVENT_SEMAPHORE_GIVE 0x51
#define PSF_EVENT_MUTEX_GIVE 0x52

#define PSF_EVENT_QUEUE_SEND_FAILED 0x53
#define PSF_EVENT_SEMAPHORE_GIVE_FAILED 0x54
#define PSF_EVENT_MUTEX_GIVE_FAILED 0x55

#define PSF_EVENT_QUEUE_SEND_BLOCK 0x56
#define PSF_EVENT_SEMAPHORE_GIVE_BLOCK 0x57
#define PSF_EVENT_MUTEX_GIVE_BLOCK 0x58

#define PSF_EVENT_QUEUE_SEND_FROMISR 0x59
#define PSF_EVENT_SEMAPHORE_GIVE_FROMISR 0x5A

#define PSF_EVENT_QUEUE_SEND_FROMISR_FAILED 0x5C
#define PSF_EVENT_SEMAPHORE_GIVE_FROMISR_FAILED 0x5D

#define PSF_EVENT_QUEUE_RECEIVE 0x60
#define PSF_EVENT_SEMAPHORE_TAKE 0x61
#define PSF_EVENT_MUTEX_TAKE 0x62

#define PSF_EVENT_QUEUE_RECEIVE_FAILED 0x63
#define PSF_EVENT_SEMAPHORE_TAKE_FAILED 0x64
#define PSF_EVENT_MUTEX_TAKE_FAILED 0x65

#define PSF_EVENT_QUEUE_RECEIVE_BLOCK 0x66
#define PSF_EVENT_SEMAPHORE_TAKE_BLOCK 0x67
#define PSF_EVENT_MUTEX_TAKE_BLOCK 0x68

#define PSF_EVENT_QUEUE_RECEIVE_FROMISR 0x69
#define PSF_EVENT_SEMAPHORE_TAKE_FROMISR 0x6A

#define PSF_EVENT_QUEUE_RECEIVE_FROMISR_FAILED 0x6C
#define PSF_EVENT_SEMAPHORE_TAKE_FROMISR_FAILED 0x6D

#define PSF_EVENT_QUEUE_PEEK 0x70
#define PSF_EVENT_SEMAPHORE_PEEK 0x71
#define PSF_EVENT_MUTEX_PEEK 0x72

#define PSF_EVENT_QUEUE_PEEK_FAILED 0x73
#define PSF_EVENT_SEMAPHORE_PEEK_FAILED 0x74
#define PSF_EVENT_MUTEX_PEEK_FAILED 0x75

#define PSF_EVENT_QUEUE_PEEK_BLOCK 0x76
#define PSF_EVENT_SEMAPHORE_PEEK_BLOCK 0x77
#define PSF_EVENT_MUTEX_PEEK_BLOCK 0x78

#define PSF_EVENT_TASK_DELAY_UNTIL 0x79
#define PSF_EVENT_TASK_DELAY 0x7A
#define PSF_EVENT_TASK_SUSPEND 0x7B
#define PSF_EVENT_TASK_RESUME 0x7C
#define PSF_EVENT_TASK_RESUME_FROMISR 0x7D

#define PSF_EVENT_TIMER_PENDFUNCCALL 0x80
#define PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR 0x81
#define PSF_EVENT_TIMER_PENDFUNCCALL_FAILED 0x82
#define PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR_FAILED 0x83

#define PSF_EVENT_USER_EVENT 0x90

#define PSF_EVENT_TIMER_START 0xA0
#define PSF_EVENT_TIMER_RESET 0xA1
#define PSF_EVENT_TIMER_STOP 0xA2
#define PSF_EVENT_TIMER_CHANGEPERIOD 0xA3
#define PSF_EVENT_TIMER_START_FROMISR 0xA4
#define PSF_EVENT_TIMER_RESET_FROMISR 0xA5
#define PSF_EVENT_TIMER_STOP_FROMISR 0xA6
#define PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR 0xA7
#define PSF_EVENT_TIMER_START_FAILED 0xA8
#define PSF_EVENT_TIMER_RESET_FAILED 0xA9
#define PSF_EVENT_TIMER_STOP_FAILED 0xAA
#define PSF_EVENT_TIMER_CHANGEPERIOD_FAILED 0xAB
#define PSF_EVENT_TIMER_START_FROMISR_FAILED 0xAC
#define PSF_EVENT_TIMER_RESET_FROMISR_FAILED 0xAD
#define PSF_EVENT_TIMER_STOP_FROMISR_FAILED 0xAE
#define PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR_FAILED 0xAF

#define PSF_EVENT_EVENTGROUP_SYNC 0xB0
#define PSF_EVENT_EVENTGROUP_WAITBITS 0xB1
#define PSF_EVENT_EVENTGROUP_CLEARBITS 0xB2
#define PSF_EVENT_EVENTGROUP_CLEARBITS_FROMISR 0xB3
#define PSF_EVENT_EVENTGROUP_SETBITS 0xB4
#define PSF_EVENT_EVENTGROUP_SETBITS_FROMISR 0xB5
#define PSF_EVENT_EVENTGROUP_SYNC_BLOCK 0xB6
#define PSF_EVENT_EVENTGROUP_WAITBITS_BLOCK 0xB7
#define PSF_EVENT_EVENTGROUP_SYNC_FAILED 0xB8
#define PSF_EVENT_EVENTGROUP_WAITBITS_FAILED 0xB9

#define PSF_EVENT_QUEUE_SEND_FRONT 0xC0
#define PSF_EVENT_QUEUE_SEND_FRONT_FAILED 0xC1
#define PSF_EVENT_QUEUE_SEND_FRONT_BLOCK 0xC2
#define PSF_EVENT_QUEUE_SEND_FRONT_FROMISR 0xC3
#define PSF_EVENT_QUEUE_SEND_FRONT_FROMISR_FAILED 0xC4
#define PSF_EVENT_MUTEX_GIVE_RECURSIVE 0xC5
#define PSF_EVENT_MUTEX_GIVE_RECURSIVE_FAILED 0xC6
#define PSF_EVENT_MUTEX_TAKE_RECURSIVE 0xC7
#define PSF_EVENT_MUTEX_TAKE_RECURSIVE_FAILED 0xC8

#define PSF_EVENT_TASK_NOTIFY 0xC9
#define PSF_EVENT_TASK_NOTIFY_TAKE 0xCA
#define PSF_EVENT_TASK_NOTIFY_TAKE_BLOCK 0xCB
#define PSF_EVENT_TASK_NOTIFY_TAKE_FAILED 0xCC
#define PSF_EVENT_TASK_NOTIFY_WAIT 0xCD
#define PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK 0xCE
#define PSF_EVENT_TASK_NOTIFY_WAIT_FAILED 0xCF
#define PSF_EVENT_TASK_NOTIFY_FROM_ISR 0xD0
#define PSF_EVENT_TASK_NOTIFY_GIVE_FROM_ISR 0xD1

#define PSF_EVENT_TIMER_EXPIRED 0xD2

#define PSF_EVENT_STREAMBUFFER_SEND 0xD3
#define PSF_EVENT_STREAMBUFFER_SEND_BLOCK 0xD4
#define PSF_EVENT_STREAMBUFFER_SEND_FAILED 0xD5
#define PSF_EVENT_STREAMBUFFER_RECEIVE 0xD6
#define PSF_EVENT_STREAMBUFFER_RECEIVE_BLOCK 0xD7
#define PSF_EVENT_STREAMBUFFER_RECEIVE_FAILED 0xD8
#define PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR 0xD9
#define PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR_FAILED 0xDA
#define PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR 0xDB
#define PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR_FAILED 0xDC
#define PSF_EVENT_STREAMBUFFER_RESET 0xDD

#define PSF_EVENT_MESSAGEBUFFER_SEND 0xDE
#define PSF_EVENT_MESSAGEBUFFER_SEND_BLOCK 0xDF
#define PSF_EVENT_MESSAGEBUFFER_SEND_FAILED 0xE0
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE 0xE1
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE_BLOCK 0xE2
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE_FAILED 0xE3
#define PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR 0xE4
#define PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR_FAILED 0xE5
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR 0xE6
#define PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR_FAILED 0xE7
#define PSF_EVENT_MESSAGEBUFFER_RESET 0xE8

/*** The trace macros for streaming ******************************************/

#if (defined(configUSE_TICKLESS_IDLE) && configUSE_TICKLESS_IDLE != 0)

#undef traceLOW_POWER_IDLE_BEGIN
#define traceLOW_POWER_IDLE_BEGIN()                                                                                    \
	{                                                                                                                  \
		prvTraceStoreEvent1(PSF_EVENT_LOWPOWER_BEGIN, xExpectedIdleTime);                                              \
	}

#undef traceLOW_POWER_IDLE_END
#define traceLOW_POWER_IDLE_END()                                                                                      \
	{                                                                                                                  \
		prvTraceStoreEvent0(PSF_EVENT_LOWPOWER_END);                                                                   \
	}

#endif

/* A macro that will update the tick count when returning from tickless idle */
#undef traceINCREASE_TICK_COUNT
/* Note: This can handle time adjustments of max 2^32 ticks, i.e., 35 seconds at 120 MHz. Thus, tick-less idle periods
 * longer than 2^32 ticks will appear "compressed" on the time line.*/
#define traceINCREASE_TICK_COUNT(xCount)                                                                               \
	{                                                                                                                  \
		extern uint32_t uiTraceTickCount;                                                                              \
		uiTraceTickCount += xCount;                                                                                    \
	}

/* Called for each task that becomes ready */
#if (TRC_CFG_INCLUDE_READY_EVENTS == 1)
#undef traceMOVED_TASK_TO_READY_STATE
#define traceMOVED_TASK_TO_READY_STATE(pxTCB)                                                                          \
	if (TRACE_GET_TASK_FILTER(pxTCB) & CurrentFilterMask)                                                              \
		prvTraceStoreEvent1(PSF_EVENT_TASK_READY, (Pointer_UBaseType_t)pxTCB);
#endif

#if (TRC_CFG_INCLUDE_OSTICK_EVENTS == 1)
#define OS_TICK_EVENT(uxSchedulerSuspended, xTickCount)                                                                \
	if (uxSchedulerSuspended == (unsigned portBASE_TYPE)pdFALSE) {                                                     \
		prvTraceStoreEvent1(PSF_EVENT_NEW_TIME, (uint32_t)(xTickCount + 1));                                           \
	}
#else
#define OS_TICK_EVENT(uxSchedulerSuspended, xTickCount)
#endif

/* Called on each OS tick. Will call uiPortGetTimestamp to make sure it is called at least once every OS tick. */
#undef traceTASK_INCREMENT_TICK
#if TRC_CFG_FREERTOS_VERSION <= TRC_FREERTOS_VERSION_7_4
#define traceTASK_INCREMENT_TICK(xTickCount)                                                                           \
	if (uxSchedulerSuspended == (unsigned portBASE_TYPE)pdTRUE || uxMissedTicks == 0) {                                \
		extern uint32_t uiTraceTickCount;                                                                              \
		uiTraceTickCount++;                                                                                            \
	}                                                                                                                  \
	OS_TICK_EVENT(uxSchedulerSuspended, xTickCount)
#else
#define traceTASK_INCREMENT_TICK(xTickCount)                                                                           \
	if (uxSchedulerSuspended == (unsigned portBASE_TYPE)pdTRUE || uxPendedTicks == 0) {                                \
		extern uint32_t uiTraceTickCount;                                                                              \
		uiTraceTickCount++;                                                                                            \
	}                                                                                                                  \
	OS_TICK_EVENT(uxSchedulerSuspended, xTickCount)
#endif /* TRC_CFG_FREERTOS_VERSION <= TRC_FREERTOS_VERSION_7_4 */

#undef traceTASK_CREATE
#if TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0
#define traceTASK_CREATE(pxNewTCB)                                                                                     \
	if (pxNewTCB != NULL) {                                                                                            \
		prvTraceSaveSymbol(pxNewTCB, pxNewTCB->pcTaskName);                                                            \
		prvTraceSaveObjectData(pxNewTCB, pxNewTCB->uxPriority);                                                        \
		prvTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, pxNewTCB->pcTaskName, pxNewTCB);                               \
		TRACE_SET_TASK_FILTER(pxNewTCB, CurrentFilterGroup);                                                           \
		prvTraceStoreEvent2(PSF_EVENT_TASK_CREATE, (Pointer_UBaseType_t)pxNewTCB, pxNewTCB->uxPriority);               \
	}
#else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */
#define traceTASK_CREATE(pxNewTCB)                                                                                     \
	if (pxNewTCB != NULL) {                                                                                            \
		prvTraceSaveSymbol(pxNewTCB, (const char *)pcName);                                                            \
		prvTraceSaveObjectData(pxNewTCB, uxPriority);                                                                  \
		prvTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, (const char *)pcName, pxNewTCB);                               \
		TRACE_SET_TASK_FILTER(pxNewTCB, CurrentFilterGroup);                                                           \
		prvTraceStoreEvent2(PSF_EVENT_TASK_CREATE, (uint32_t)pxNewTCB, uxPriority);                                    \
	}
#endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */

/* Called in vTaskCreate, if it fails (typically if the stack can not be allocated) */
#undef traceTASK_CREATE_FAILED
#define traceTASK_CREATE_FAILED() prvTraceStoreEvent0(PSF_EVENT_TASK_CREATE_FAILED);

/* Called on vTaskDelete */
#undef traceTASK_DELETE // We don't allow for filtering out "delete" events. They are important and not very frequent.
                        // Moreover, we can't exclude create events, so this should be symmetrical.
#define traceTASK_DELETE(pxTaskToDelete)                                                                               \
	prvTraceStoreEvent2(                                                                                               \
	    PSF_EVENT_TASK_DELETE, (uint32_t)pxTaskToDelete, (pxTaskToDelete != NULL) ? (pxTaskToDelete->uxPriority) : 0); \
	prvTraceDeleteSymbol(pxTaskToDelete);                                                                              \
	prvTraceDeleteObjectData(pxTaskToDelete);

/* Called on each task-switch */
#undef traceTASK_SWITCHED_IN
#define traceTASK_SWITCHED_IN()                                                                                        \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (prvIsNewTCB(pxCurrentTCB)) {                                                                               \
			prvTraceStoreEvent2(PSF_EVENT_TASK_ACTIVATE, (Pointer_UBaseType_t)pxCurrentTCB, pxCurrentTCB->uxPriority); \
		}

#if (TRC_CFG_SCHEDULING_ONLY == 0)

/* Called on vTaskSuspend */
#undef traceTASK_SUSPEND
#define traceTASK_SUSPEND(pxTaskToSuspend)                                                                             \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreEvent1(PSF_EVENT_TASK_SUSPEND, (Pointer_UBaseType_t)pxTaskToSuspend);

/* Called on vTaskDelay - note the use of FreeRTOS variable xTicksToDelay */
#undef traceTASK_DELAY
#define traceTASK_DELAY()                                                                                              \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreEvent1(PSF_EVENT_TASK_DELAY, xTicksToDelay);

/* Called on vTaskDelayUntil - note the use of FreeRTOS variable xTimeToWake */
#undef traceTASK_DELAY_UNTIL
#if TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0
#define traceTASK_DELAY_UNTIL(xTimeToWake)                                                                             \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreEvent1(PSF_EVENT_TASK_DELAY_UNTIL, (uint32_t)xTimeToWake);
#else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */
#define traceTASK_DELAY_UNTIL()                                                                                        \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreEvent1(PSF_EVENT_TASK_DELAY_UNTIL, (uint32_t)xTimeToWake);
#endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0)
#define traceQUEUE_CREATE_HELPER()                                                                                     \
	case queueQUEUE_TYPE_MUTEX:                                                                                        \
		prvTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE, (Pointer_UBaseType_t)pxNewQueue);                                  \
		break;                                                                                                         \
	case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                              \
		prvTraceStoreEvent1(PSF_EVENT_MUTEX_RECURSIVE_CREATE, (Pointer_UBaseType_t)pxNewQueue);                        \
		break;
#else
#define traceQUEUE_CREATE_HELPER()
#endif /* (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) */

/* Called in xQueueCreate, and thereby for all other object based on queues, such as semaphores. */
#undef traceQUEUE_CREATE
#define traceQUEUE_CREATE(pxNewQueue)                                                                                  \
	TRACE_SET_OBJECT_FILTER(QUEUE, pxNewQueue, CurrentFilterGroup);                                                    \
	switch (pxNewQueue->ucQueueType) {                                                                                 \
	case queueQUEUE_TYPE_BASE:                                                                                         \
		prvTraceStoreEvent2(PSF_EVENT_QUEUE_CREATE, (Pointer_UBaseType_t)pxNewQueue, uxQueueLength);                   \
		break;                                                                                                         \
	case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                             \
		prvTraceStoreEvent1(PSF_EVENT_SEMAPHORE_BINARY_CREATE, (Pointer_UBaseType_t)pxNewQueue);                       \
		break;                                                                                                         \
		traceQUEUE_CREATE_HELPER()                                                                                     \
	}

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0)
#define traceQUEUE_CREATE_FAILED_HELPER()                                                                              \
	case queueQUEUE_TYPE_MUTEX:                                                                                        \
		prvTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE_FAILED, 0);                                                         \
		break;                                                                                                         \
	case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                              \
		prvTraceStoreEvent1(PSF_EVENT_MUTEX_RECURSIVE_CREATE_FAILED, 0);                                               \
		break;
#else
#define traceQUEUE_CREATE_FAILED_HELPER()
#endif /* (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) */

/* Called in xQueueCreate, if the queue creation fails */
#undef traceQUEUE_CREATE_FAILED
#define traceQUEUE_CREATE_FAILED(queueType)                                                                            \
	switch (queueType) {                                                                                               \
	case queueQUEUE_TYPE_BASE:                                                                                         \
		prvTraceStoreEvent2(PSF_EVENT_QUEUE_CREATE_FAILED, 0, uxQueueLength);                                          \
		break;                                                                                                         \
	case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                             \
		prvTraceStoreEvent1(PSF_EVENT_SEMAPHORE_BINARY_CREATE_FAILED, 0);                                              \
		break;                                                                                                         \
		traceQUEUE_CREATE_FAILED_HELPER()                                                                              \
	}

#undef traceQUEUE_DELETE // We don't allow for filtering out "delete" events. They are important and not very frequent.
                         // Moreover, we can't exclude create events, so this should be symmetrical.
#define traceQUEUE_DELETE(pxQueue)                                                                                     \
	switch (pxQueue->ucQueueType) {                                                                                    \
	case queueQUEUE_TYPE_BASE:                                                                                         \
		prvTraceStoreEvent2(PSF_EVENT_QUEUE_DELETE,                                                                    \
		                    (Pointer_UBaseType_t)pxQueue,                                                              \
		                    (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0);                                     \
		break;                                                                                                         \
	case queueQUEUE_TYPE_MUTEX:                                                                                        \
	case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                              \
		prvTraceStoreEvent2(PSF_EVENT_MUTEX_DELETE,                                                                    \
		                    (Pointer_UBaseType_t)pxQueue,                                                              \
		                    (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0);                                     \
		break;                                                                                                         \
	case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                           \
	case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                             \
		prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_DELETE,                                                                \
		                    (Pointer_UBaseType_t)pxQueue,                                                              \
		                    (pxQueue != NULL) ? (pxQueue->uxMessagesWaiting) : 0);                                     \
		break;                                                                                                         \
	}                                                                                                                  \
	prvTraceDeleteSymbol(pxQueue);

/* Called in xQueueCreateCountingSemaphore, if the queue creation fails */
#undef traceCREATE_COUNTING_SEMAPHORE
#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X)
#define traceCREATE_COUNTING_SEMAPHORE()                                                                               \
	TRACE_SET_OBJECT_FILTER(QUEUE, xHandle, CurrentFilterGroup);                                                       \
	prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)xHandle, uxMaxCount);
#elif (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_5_OR_7_6)
#define traceCREATE_COUNTING_SEMAPHORE()                                                                               \
	TRACE_SET_OBJECT_FILTER(QUEUE, xHandle, CurrentFilterGroup);                                                       \
	prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)xHandle, uxInitialCount);
#elif (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_4)
#define traceCREATE_COUNTING_SEMAPHORE()                                                                               \
	TRACE_SET_OBJECT_FILTER(QUEUE, xHandle, CurrentFilterGroup);                                                       \
	prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)xHandle, uxCountValue);
#else
#define traceCREATE_COUNTING_SEMAPHORE()                                                                               \
	TRACE_SET_OBJECT_FILTER(QUEUE, pxHandle, CurrentFilterGroup);                                                      \
	prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE, (uint32_t)pxHandle, uxCountValue);
#endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X */

#undef traceCREATE_COUNTING_SEMAPHORE_FAILED
#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X)
#define traceCREATE_COUNTING_SEMAPHORE_FAILED()                                                                        \
	TRACE_SET_OBJECT_FILTER(QUEUE, xHandle, CurrentFilterGroup);                                                       \
	prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED, 0, uxMaxCount);
#elif (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_5_OR_7_6)
#define traceCREATE_COUNTING_SEMAPHORE_FAILED()                                                                        \
	TRACE_SET_OBJECT_FILTER(QUEUE, xHandle, CurrentFilterGroup);                                                       \
	prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED, 0, uxInitialCount);
#elif (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_7_4)
#define traceCREATE_COUNTING_SEMAPHORE_FAILED()                                                                        \
	TRACE_SET_OBJECT_FILTER(QUEUE, xHandle, CurrentFilterGroup);                                                       \
	prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED, 0, uxCountValue);
#else
#define traceCREATE_COUNTING_SEMAPHORE_FAILED()                                                                        \
	TRACE_SET_OBJECT_FILTER(QUEUE, pxHandle, CurrentFilterGroup);                                                      \
	prvTraceStoreEvent2(PSF_EVENT_SEMAPHORE_COUNTING_CREATE_FAILED, 0, uxCountValue);
#endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X */

/* This macro is not necessary as of FreeRTOS v9.0.0 */
#if (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0)
/* Called in xQueueCreateMutex, and thereby also from xSemaphoreCreateMutex and xSemaphoreCreateRecursiveMutex */
#undef traceCREATE_MUTEX
#define traceCREATE_MUTEX(pxNewQueue)                                                                                  \
	TRACE_SET_OBJECT_FILTER(TIMER, pxNewQueue, CurrentFilterGroup);                                                    \
	switch (pxNewQueue->ucQueueType) {                                                                                 \
	case queueQUEUE_TYPE_MUTEX:                                                                                        \
		prvTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE, (uint32_t)pxNewQueue);                                             \
		break;                                                                                                         \
	case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                              \
		prvTraceStoreEvent1(PSF_EVENT_MUTEX_RECURSIVE_CREATE, (uint32_t)pxNewQueue);                                   \
		break;                                                                                                         \
	}

/* Called in xQueueCreateMutex when the operation fails (when memory allocation fails) */
#undef traceCREATE_MUTEX_FAILED
#define traceCREATE_MUTEX_FAILED() prvTraceStoreEvent1(PSF_EVENT_MUTEX_CREATE_FAILED, 0);
#endif /* (TRC_CFG_FREERTOS_VERSION < TRC_FREERTOS_VERSION_9_0_0) */

/* Called when a message is sent to a queue */ /* CS IS NEW ! */
#undef traceQUEUE_SEND
#define traceQUEUE_SEND(pxQueue)                                                                                       \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                               \
			switch (pxQueue->ucQueueType) {                                                                            \
			case queueQUEUE_TYPE_BASE:                                                                                 \
				prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND                          \
				                                                       : PSF_EVENT_QUEUE_SEND_FRONT,                   \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    pxQueue->uxMessagesWaiting + 1);                                                   \
				break;                                                                                                 \
			case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                     \
			case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                   \
				prvTraceStoreEvent2(                                                                                   \
				    PSF_EVENT_SEMAPHORE_GIVE, (Pointer_UBaseType_t)pxQueue, pxQueue->uxMessagesWaiting + 1);           \
				break;                                                                                                 \
			case queueQUEUE_TYPE_MUTEX:                                                                                \
			case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                      \
				prvTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE, (Pointer_UBaseType_t)pxQueue);                               \
				break;                                                                                                 \
			}

/* Called when a message failed to be sent to a queue (timeout) */
#undef traceQUEUE_SEND_FAILED
#define traceQUEUE_SEND_FAILED(pxQueue)                                                                                \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                               \
			switch (pxQueue->ucQueueType) {                                                                            \
			case queueQUEUE_TYPE_BASE:                                                                                 \
				prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FAILED                   \
				                                                       : PSF_EVENT_QUEUE_SEND_FRONT_FAILED,            \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                     \
			case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                   \
				prvTraceStoreEvent2(                                                                                   \
				    PSF_EVENT_SEMAPHORE_GIVE_FAILED, (Pointer_UBaseType_t)pxQueue, pxQueue->uxMessagesWaiting);        \
				break;                                                                                                 \
			case queueQUEUE_TYPE_MUTEX:                                                                                \
			case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                      \
				prvTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_FAILED, (Pointer_UBaseType_t)pxQueue);                        \
				break;                                                                                                 \
			}

/* Called when the task is blocked due to a send operation on a full queue */
#undef traceBLOCKING_ON_QUEUE_SEND
#define traceBLOCKING_ON_QUEUE_SEND(pxQueue)                                                                           \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                               \
			switch (pxQueue->ucQueueType) {                                                                            \
			case queueQUEUE_TYPE_BASE:                                                                                 \
				prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_BLOCK                    \
				                                                       : PSF_EVENT_QUEUE_SEND_FRONT_BLOCK,             \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                     \
			case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                   \
				prvTraceStoreEvent2(                                                                                   \
				    PSF_EVENT_SEMAPHORE_GIVE_BLOCK, (Pointer_UBaseType_t)pxQueue, pxQueue->uxMessagesWaiting);         \
				break;                                                                                                 \
			case queueQUEUE_TYPE_MUTEX:                                                                                \
			case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                      \
				prvTraceStoreEvent1(PSF_EVENT_MUTEX_GIVE_BLOCK, (Pointer_UBaseType_t)pxQueue);                         \
				break;                                                                                                 \
			}

/**************************************************************************/
/* Makes sure xQueueGiveFromISR also has a xCopyPosition parameter        */
/**************************************************************************/
/* Helpers needed to correctly expand names */
#define TZ__CAT2(a, b) a##b
#define TZ__CAT(a, b) TZ__CAT2(a, b)

/* Expands name if this header is included... uxQueueType must be a macro that only exists in queue.c or whatever, and
 * it must expand to nothing or to something that's valid in identifiers */
#define xQueueGiveFromISR(a, b) TZ__CAT(xQueueGiveFromISR__, uxQueueType)(a, b)

/* If in queue.c, the "uxQueueType" macro expands to "pcHead". queueSEND_TO_BACK is the value we need to send in */
#define xQueueGiveFromISR__pcHead(__a, __b)                                                                            \
	MyWrapper(__a, __b, const BaseType_t xCopyPosition);                                                               \
	BaseType_t xQueueGiveFromISR(__a, __b)                                                                             \
	{                                                                                                                  \
		return MyWrapper(xQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK);                                        \
	}                                                                                                                  \
	BaseType_t MyWrapper(__a, __b, const BaseType_t xCopyPosition)

/* If not in queue.c, "uxQueueType" isn't expanded */
#define xQueueGiveFromISR__uxQueueType(__a, __b) xQueueGiveFromISR(__a, __b)

/**************************************************************************/
/* End of xQueueGiveFromISR fix                                           */
/**************************************************************************/

/* Called when a message is sent from interrupt context, e.g., using xQueueSendFromISR */
#undef traceQUEUE_SEND_FROM_ISR
#define traceQUEUE_SEND_FROM_ISR(pxQueue)                                                                              \
	if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                                   \
		switch (pxQueue->ucQueueType) {                                                                                \
		case queueQUEUE_TYPE_BASE:                                                                                     \
			prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FROMISR                      \
			                                                       : PSF_EVENT_QUEUE_SEND_FRONT_FROMISR,               \
			                    (Pointer_UBaseType_t)pxQueue,                                                          \
			                    pxQueue->uxMessagesWaiting + 1);                                                       \
			break;                                                                                                     \
		case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                         \
		case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                       \
			prvTraceStoreEvent2(                                                                                       \
			    PSF_EVENT_SEMAPHORE_GIVE_FROMISR, (Pointer_UBaseType_t)pxQueue, pxQueue->uxMessagesWaiting + 1);       \
			break;                                                                                                     \
		}

/* Called when a message send from interrupt context fails (since the queue was full) */
#undef traceQUEUE_SEND_FROM_ISR_FAILED
#define traceQUEUE_SEND_FROM_ISR_FAILED(pxQueue)                                                                       \
	if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                                   \
		switch (pxQueue->ucQueueType) {                                                                                \
		case queueQUEUE_TYPE_BASE:                                                                                     \
			prvTraceStoreEvent2(xCopyPosition == queueSEND_TO_BACK ? PSF_EVENT_QUEUE_SEND_FROMISR_FAILED               \
			                                                       : PSF_EVENT_QUEUE_SEND_FRONT_FROMISR_FAILED,        \
			                    (Pointer_UBaseType_t)pxQueue,                                                          \
			                    pxQueue->uxMessagesWaiting);                                                           \
			break;                                                                                                     \
		case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                         \
		case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                       \
			prvTraceStoreEvent2(                                                                                       \
			    PSF_EVENT_SEMAPHORE_GIVE_FROMISR_FAILED, (Pointer_UBaseType_t)pxQueue, pxQueue->uxMessagesWaiting);    \
			break;                                                                                                     \
		}

/* Called when a message is received from a queue */
#undef traceQUEUE_RECEIVE
#define traceQUEUE_RECEIVE(pxQueue)                                                                                    \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                               \
			switch (pxQueue->ucQueueType) {                                                                            \
			case queueQUEUE_TYPE_BASE:                                                                                 \
				if (isQueueReceiveHookActuallyPeek)                                                                    \
					prvTraceStoreEvent3(PSF_EVENT_QUEUE_PEEK,                                                          \
					                    (Pointer_UBaseType_t)pxQueue,                                                  \
					                    xTicksToWait,                                                                  \
					                    pxQueue->uxMessagesWaiting - 1);                                               \
				else                                                                                                   \
					prvTraceStoreEvent3(PSF_EVENT_QUEUE_RECEIVE,                                                       \
					                    (Pointer_UBaseType_t)pxQueue,                                                  \
					                    xTicksToWait,                                                                  \
					                    pxQueue->uxMessagesWaiting - 1);                                               \
				break;                                                                                                 \
			case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                     \
			case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                   \
				if (isQueueReceiveHookActuallyPeek)                                                                    \
					prvTraceStoreEvent3(PSF_EVENT_SEMAPHORE_PEEK,                                                      \
					                    (Pointer_UBaseType_t)pxQueue,                                                  \
					                    xTicksToWait,                                                                  \
					                    pxQueue->uxMessagesWaiting - 1);                                               \
				else                                                                                                   \
					prvTraceStoreEvent3(PSF_EVENT_SEMAPHORE_TAKE,                                                      \
					                    (Pointer_UBaseType_t)pxQueue,                                                  \
					                    xTicksToWait,                                                                  \
					                    pxQueue->uxMessagesWaiting - 1);                                               \
				break;                                                                                                 \
			case queueQUEUE_TYPE_MUTEX:                                                                                \
			case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                      \
				if (isQueueReceiveHookActuallyPeek)                                                                    \
					prvTraceStoreEvent2(PSF_EVENT_MUTEX_PEEK, (Pointer_UBaseType_t)pxQueue, xTicksToWait);             \
				else                                                                                                   \
					prvTraceStoreEvent2(PSF_EVENT_MUTEX_TAKE, (Pointer_UBaseType_t)pxQueue, xTicksToWait);             \
				break;                                                                                                 \
			}

/* Called when a receive operation on a queue fails (timeout) */
#undef traceQUEUE_RECEIVE_FAILED
#define traceQUEUE_RECEIVE_FAILED(pxQueue)                                                                             \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                               \
			switch (pxQueue->ucQueueType) {                                                                            \
			case queueQUEUE_TYPE_BASE:                                                                                 \
				prvTraceStoreEvent3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_QUEUE_PEEK_FAILED                       \
				                                                   : PSF_EVENT_QUEUE_RECEIVE_FAILED,                   \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait,                                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                     \
			case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                   \
				prvTraceStoreEvent3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_SEMAPHORE_PEEK_FAILED                   \
				                                                   : PSF_EVENT_SEMAPHORE_TAKE_FAILED,                  \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait,                                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_MUTEX:                                                                                \
			case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                      \
				prvTraceStoreEvent2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK_FAILED                       \
				                                                   : PSF_EVENT_MUTEX_TAKE_FAILED,                      \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait);                                                                     \
				break;                                                                                                 \
			}

/* Called when the task is blocked due to a receive operation on an empty queue */
#undef traceBLOCKING_ON_QUEUE_RECEIVE
#define traceBLOCKING_ON_QUEUE_RECEIVE(pxQueue)                                                                        \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                               \
			switch (pxQueue->ucQueueType) {                                                                            \
			case queueQUEUE_TYPE_BASE:                                                                                 \
				prvTraceStoreEvent3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_QUEUE_PEEK_BLOCK                        \
				                                                   : PSF_EVENT_QUEUE_RECEIVE_BLOCK,                    \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait,                                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                     \
			case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                   \
				prvTraceStoreEvent3(isQueueReceiveHookActuallyPeek ? PSF_EVENT_SEMAPHORE_PEEK_BLOCK                    \
				                                                   : PSF_EVENT_SEMAPHORE_TAKE_BLOCK,                   \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait,                                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_MUTEX:                                                                                \
			case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                      \
				prvTraceStoreEvent2(isQueueReceiveHookActuallyPeek ? PSF_EVENT_MUTEX_PEEK_BLOCK                        \
				                                                   : PSF_EVENT_MUTEX_TAKE_BLOCK,                       \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait);                                                                     \
				break;                                                                                                 \
			}

#if (TRC_CFG_FREERTOS_VERSION > TRC_FREERTOS_VERSION_9_0_1)
/* Called when a peek operation on a queue fails (timeout) */
#undef traceQUEUE_PEEK_FAILED
#define traceQUEUE_PEEK_FAILED(pxQueue)                                                                                \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                               \
			switch (pxQueue->ucQueueType) {                                                                            \
			case queueQUEUE_TYPE_BASE:                                                                                 \
				prvTraceStoreEvent3(PSF_EVENT_QUEUE_PEEK_FAILED,                                                       \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait,                                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                     \
			case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                   \
				prvTraceStoreEvent3(PSF_EVENT_SEMAPHORE_PEEK_FAILED,                                                   \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait,                                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_MUTEX:                                                                                \
			case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                      \
				prvTraceStoreEvent2(PSF_EVENT_MUTEX_PEEK_FAILED, (Pointer_UBaseType_t)pxQueue, xTicksToWait);          \
				break;                                                                                                 \
			}

/* Called when the task is blocked due to a peek operation on an empty queue */
#undef traceBLOCKING_ON_QUEUE_PEEK
#define traceBLOCKING_ON_QUEUE_PEEK(pxQueue)                                                                           \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                               \
			switch (pxQueue->ucQueueType) {                                                                            \
			case queueQUEUE_TYPE_BASE:                                                                                 \
				prvTraceStoreEvent3(PSF_EVENT_QUEUE_PEEK_BLOCK,                                                        \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait,                                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                     \
			case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                   \
				prvTraceStoreEvent3(PSF_EVENT_SEMAPHORE_PEEK_BLOCK,                                                    \
				                    (Pointer_UBaseType_t)pxQueue,                                                      \
				                    xTicksToWait,                                                                      \
				                    pxQueue->uxMessagesWaiting);                                                       \
				break;                                                                                                 \
			case queueQUEUE_TYPE_MUTEX:                                                                                \
			case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                      \
				prvTraceStoreEvent2(PSF_EVENT_MUTEX_PEEK_BLOCK, (Pointer_UBaseType_t)pxQueue, xTicksToWait);           \
				break;                                                                                                 \
			}

#endif /* (TRC_CFG_FREERTOS_VERSION > TRC_FREERTOS_VERSION_9_0_1) */

/* Called when a message is received in interrupt context, e.g., using xQueueReceiveFromISR */
#undef traceQUEUE_RECEIVE_FROM_ISR
#define traceQUEUE_RECEIVE_FROM_ISR(pxQueue)                                                                           \
	if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                                   \
		switch (pxQueue->ucQueueType) {                                                                                \
		case queueQUEUE_TYPE_BASE:                                                                                     \
			prvTraceStoreEvent2(                                                                                       \
			    PSF_EVENT_QUEUE_RECEIVE_FROMISR, (Pointer_UBaseType_t)pxQueue, pxQueue->uxMessagesWaiting - 1);        \
			break;                                                                                                     \
		case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                         \
		case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                       \
			prvTraceStoreEvent2(                                                                                       \
			    PSF_EVENT_SEMAPHORE_TAKE_FROMISR, (Pointer_UBaseType_t)pxQueue, pxQueue->uxMessagesWaiting - 1);       \
			break;                                                                                                     \
		}

/* Called when a message receive from interrupt context fails (since the queue was empty) */
#undef traceQUEUE_RECEIVE_FROM_ISR_FAILED
#define traceQUEUE_RECEIVE_FROM_ISR_FAILED(pxQueue)                                                                    \
	if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                                   \
		switch (pxQueue->ucQueueType) {                                                                                \
		case queueQUEUE_TYPE_BASE:                                                                                     \
			prvTraceStoreEvent2(                                                                                       \
			    PSF_EVENT_QUEUE_RECEIVE_FROMISR_FAILED, (Pointer_UBaseType_t)pxQueue, pxQueue->uxMessagesWaiting);     \
			break;                                                                                                     \
		case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                         \
		case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                       \
			prvTraceStoreEvent2(                                                                                       \
			    PSF_EVENT_SEMAPHORE_TAKE_FROMISR_FAILED, (Pointer_UBaseType_t)pxQueue, pxQueue->uxMessagesWaiting);    \
			break;                                                                                                     \
		}

/* Called on xQueuePeek */
#undef traceQUEUE_PEEK
#define traceQUEUE_PEEK(pxQueue)                                                                                       \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(QUEUE, pxQueue) & CurrentFilterMask)                                               \
			switch (pxQueue->ucQueueType) {                                                                            \
			case queueQUEUE_TYPE_BASE:                                                                                 \
				prvTraceStoreEvent3(                                                                                   \
				    PSF_EVENT_QUEUE_PEEK, (Pointer_UBaseType_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting);     \
				break;                                                                                                 \
			case queueQUEUE_TYPE_BINARY_SEMAPHORE:                                                                     \
			case queueQUEUE_TYPE_COUNTING_SEMAPHORE:                                                                   \
				prvTraceStoreEvent3(                                                                                   \
				    PSF_EVENT_SEMAPHORE_PEEK, (Pointer_UBaseType_t)pxQueue, xTicksToWait, pxQueue->uxMessagesWaiting); \
				break;                                                                                                 \
			case queueQUEUE_TYPE_MUTEX:                                                                                \
			case queueQUEUE_TYPE_RECURSIVE_MUTEX:                                                                      \
				prvTraceStoreEvent1(PSF_EVENT_MUTEX_PEEK, (Pointer_UBaseType_t)pxQueue);                               \
				break;                                                                                                 \
			}

/* Called in vTaskPrioritySet */
#undef traceTASK_PRIORITY_SET
#define traceTASK_PRIORITY_SET(pxTask, uxNewPriority)                                                                  \
	prvTraceSaveObjectData(pxTask, uxNewPriority);                                                                     \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_TASK_FILTER(pxTask) & CurrentFilterMask)                                                         \
			prvTraceStoreEvent2(PSF_EVENT_TASK_PRIORITY, (uint32_t)pxTask, uxNewPriority);

/* Called in vTaskPriorityInherit, which is called by Mutex operations */
#undef traceTASK_PRIORITY_INHERIT
#define traceTASK_PRIORITY_INHERIT(pxTask, uxNewPriority)                                                              \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_TASK_FILTER(pxTask) & CurrentFilterMask)                                                         \
			prvTraceStoreEvent2(PSF_EVENT_TASK_PRIO_INHERIT, (Pointer_UBaseType_t)pxTask, uxNewPriority);

/* Called in vTaskPriorityDisinherit, which is called by Mutex operations */
#undef traceTASK_PRIORITY_DISINHERIT
#define traceTASK_PRIORITY_DISINHERIT(pxTask, uxNewPriority)                                                           \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_TASK_FILTER(pxTask) & CurrentFilterMask)                                                         \
			prvTraceStoreEvent2(PSF_EVENT_TASK_PRIO_DISINHERIT, (Pointer_UBaseType_t)pxTask, uxNewPriority);

/* Called in vTaskResume */
#undef traceTASK_RESUME
#define traceTASK_RESUME(pxTaskToResume)                                                                               \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_TASK_FILTER(pxTaskToResume) & CurrentFilterMask)                                                 \
			prvTraceStoreEvent1(PSF_EVENT_TASK_RESUME, (Pointer_UBaseType_t)pxTaskToResume);

/* Called in vTaskResumeFromISR */
#undef traceTASK_RESUME_FROM_ISR
#define traceTASK_RESUME_FROM_ISR(pxTaskToResume)                                                                      \
	if (TRACE_GET_TASK_FILTER(pxTaskToResume) & CurrentFilterMask)                                                     \
		prvTraceStoreEvent1(PSF_EVENT_TASK_RESUME_FROMISR, (Pointer_UBaseType_t)pxTaskToResume);

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) */

#if (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1)

#undef traceMALLOC
#define traceMALLOC(pvAddress, uiSize)                                                                                 \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreEvent2(PSF_EVENT_MALLOC, (Pointer_UBaseType_t)pvAddress, uiSize);

#undef traceFREE
#define traceFREE(pvAddress, uiSize)                                                                                   \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreEvent2(PSF_EVENT_FREE,                                                                            \
		                    (uint32_t)pvAddress,                                                                       \
		                    (uint32_t)(0 - uiSize)); /* "0 -" instead of just "-" to get rid of a warning... */

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1) */

#if (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_TIMER_EVENTS == 1)
/* Called in timer.c - xTimerCreate */
#undef traceTIMER_CREATE
#define traceTIMER_CREATE(tmr)                                                                                         \
	TRACE_SET_OBJECT_FILTER(TIMER, tmr, CurrentFilterGroup);                                                           \
	prvTraceSaveSymbol(tmr, tmr->pcTimerName);                                                                         \
	prvTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, tmr->pcTimerName, tmr);                                            \
	prvTraceStoreEvent2(PSF_EVENT_TIMER_CREATE, (Pointer_UBaseType_t)tmr, tmr->xTimerPeriodInTicks);

#undef traceTIMER_CREATE_FAILED
#define traceTIMER_CREATE_FAILED() prvTraceStoreEvent0(PSF_EVENT_TIMER_CREATE_FAILED);

#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X)
#define traceTIMER_COMMAND_SEND_8_0_CASES(tmr)                                                                         \
	case tmrCOMMAND_RESET:                                                                                             \
		prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET : PSF_EVENT_TIMER_RESET_FAILED,                \
		                    (Pointer_UBaseType_t)tmr,                                                                  \
		                    xOptionalValue);                                                                           \
		break;                                                                                                         \
	case tmrCOMMAND_START_FROM_ISR:                                                                                    \
		prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_START_FROMISR                                        \
		                                        : PSF_EVENT_TIMER_START_FROMISR_FAILED,                                \
		                    (Pointer_UBaseType_t)tmr,                                                                  \
		                    xOptionalValue);                                                                           \
		break;                                                                                                         \
	case tmrCOMMAND_RESET_FROM_ISR:                                                                                    \
		prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_RESET_FROMISR                                        \
		                                        : PSF_EVENT_TIMER_RESET_FROMISR_FAILED,                                \
		                    (Pointer_UBaseType_t)tmr,                                                                  \
		                    xOptionalValue);                                                                           \
		break;                                                                                                         \
	case tmrCOMMAND_STOP_FROM_ISR:                                                                                     \
		prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_STOP_FROMISR : PSF_EVENT_TIMER_STOP_FROMISR_FAILED,  \
		                    (Pointer_UBaseType_t)tmr,                                                                  \
		                    xOptionalValue);                                                                           \
		break;                                                                                                         \
	case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR:                                                                            \
		prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR                                 \
		                                        : PSF_EVENT_TIMER_CHANGEPERIOD_FROMISR_FAILED,                         \
		                    (Pointer_UBaseType_t)tmr,                                                                  \
		                    xOptionalValue);                                                                           \
		break;
#else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X */
#define traceTIMER_COMMAND_SEND_8_0_CASES(tmr)
#endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_8_X */

/* Note that xCommandID can never be tmrCOMMAND_EXECUTE_CALLBACK (-1) since the trace macro is not called in that case
 */
#undef traceTIMER_COMMAND_SEND
#define traceTIMER_COMMAND_SEND(tmr, xCommandID, xOptionalValue, xReturn)                                              \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(TIMER, tmr) & CurrentFilterMask)                                                   \
			switch (xCommandID) {                                                                                      \
			case tmrCOMMAND_START:                                                                                     \
				prvTraceStoreEvent1((xReturn == pdPASS) ? PSF_EVENT_TIMER_START : PSF_EVENT_TIMER_START_FAILED,        \
				                    (Pointer_UBaseType_t)tmr);                                                         \
				break;                                                                                                 \
			case tmrCOMMAND_STOP:                                                                                      \
				prvTraceStoreEvent1((xReturn == pdPASS) ? PSF_EVENT_TIMER_STOP : PSF_EVENT_TIMER_STOP_FAILED,          \
				                    (Pointer_UBaseType_t)tmr);                                                         \
				break;                                                                                                 \
			case tmrCOMMAND_CHANGE_PERIOD:                                                                             \
				prvTraceStoreEvent2((xReturn == pdPASS) ? PSF_EVENT_TIMER_CHANGEPERIOD                                 \
				                                        : PSF_EVENT_TIMER_CHANGEPERIOD_FAILED,                         \
				                    (Pointer_UBaseType_t)tmr,                                                          \
				                    xOptionalValue);                                                                   \
				break;                                                                                                 \
			case tmrCOMMAND_DELETE:                                                                                    \
				prvTraceStoreEvent1((xReturn == pdPASS) ? PSF_EVENT_TIMER_DELETE : PSF_EVENT_TIMER_DELETE_FAILED,      \
				                    (Pointer_UBaseType_t)tmr);                                                         \
				break;                                                                                                 \
				traceTIMER_COMMAND_SEND_8_0_CASES(tmr)                                                                 \
			}

#undef traceTIMER_EXPIRED
#define traceTIMER_EXPIRED(tmr)                                                                                        \
	prvTraceStoreEvent2(                                                                                               \
	    PSF_EVENT_TIMER_EXPIRED, (Pointer_UBaseType_t)tmr->pxCallbackFunction, (Pointer_UBaseType_t)tmr->pvTimerID);

#endif /* #if (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_TIMER_EVENTS == 1) */

#if (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS == 1)

#undef tracePEND_FUNC_CALL
#define tracePEND_FUNC_CALL(func, arg1, arg2, ret)                                                                     \
	prvTraceStoreEvent1((ret == pdPASS) ? PSF_EVENT_TIMER_PENDFUNCCALL : PSF_EVENT_TIMER_PENDFUNCCALL_FAILED,          \
	                    (uint32_t)func);

#undef tracePEND_FUNC_CALL_FROM_ISR
#define tracePEND_FUNC_CALL_FROM_ISR(func, arg1, arg2, ret)                                                            \
	prvTraceStoreEvent1((ret == pdPASS) ? PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR                                         \
	                                    : PSF_EVENT_TIMER_PENDFUNCCALL_FROMISR_FAILED,                                 \
	                    (uint32_t)func);

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS == 1) */

#if (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1)

#undef traceEVENT_GROUP_CREATE
#define traceEVENT_GROUP_CREATE(eg)                                                                                    \
	TRACE_SET_OBJECT_FILTER(EVENTGROUP, eg, CurrentFilterGroup);                                                       \
	prvTraceStoreEvent1(PSF_EVENT_EVENTGROUP_CREATE, (Pointer_UBaseType_t)eg);

#undef traceEVENT_GROUP_DELETE
#define traceEVENT_GROUP_DELETE(eg)                                                                                    \
	prvTraceStoreEvent1(PSF_EVENT_EVENTGROUP_DELETE, (Pointer_UBaseType_t)eg);                                         \
	prvTraceDeleteSymbol(eg);

#undef traceEVENT_GROUP_CREATE_FAILED
#define traceEVENT_GROUP_CREATE_FAILED() prvTraceStoreEvent0(PSF_EVENT_EVENTGROUP_CREATE_FAILED);

#undef traceEVENT_GROUP_SYNC_BLOCK
#define traceEVENT_GROUP_SYNC_BLOCK(eg, bitsToSet, bitsToWaitFor)                                                      \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask)                                               \
			prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SYNC_BLOCK, (Pointer_UBaseType_t)eg, bitsToWaitFor);

#undef traceEVENT_GROUP_SYNC_END
#define traceEVENT_GROUP_SYNC_END(eg, bitsToSet, bitsToWaitFor, wasTimeout)                                            \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask)                                               \
			prvTraceStoreEvent2((wasTimeout != pdTRUE) ? PSF_EVENT_EVENTGROUP_SYNC : PSF_EVENT_EVENTGROUP_SYNC_FAILED, \
			                    (Pointer_UBaseType_t)eg,                                                               \
			                    bitsToWaitFor);

#undef traceEVENT_GROUP_WAIT_BITS_BLOCK
#define traceEVENT_GROUP_WAIT_BITS_BLOCK(eg, bitsToWaitFor)                                                            \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask)                                               \
			prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_WAITBITS_BLOCK, (Pointer_UBaseType_t)eg, bitsToWaitFor);

#undef traceEVENT_GROUP_WAIT_BITS_END
#define traceEVENT_GROUP_WAIT_BITS_END(eg, bitsToWaitFor, wasTimeout)                                                  \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask)                                               \
			prvTraceStoreEvent2((wasTimeout != pdTRUE) ? PSF_EVENT_EVENTGROUP_WAITBITS                                 \
			                                           : PSF_EVENT_EVENTGROUP_WAITBITS_FAILED,                         \
			                    (Pointer_UBaseType_t)eg,                                                               \
			                    bitsToWaitFor);

#undef traceEVENT_GROUP_CLEAR_BITS
#define traceEVENT_GROUP_CLEAR_BITS(eg, bitsToClear)                                                                   \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask)                                               \
			prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_CLEARBITS, (Pointer_UBaseType_t)eg, bitsToClear);

#undef traceEVENT_GROUP_CLEAR_BITS_FROM_ISR
#define traceEVENT_GROUP_CLEAR_BITS_FROM_ISR(eg, bitsToClear)                                                          \
	if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask)                                                   \
		prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_CLEARBITS_FROMISR, (uint32_t)eg, bitsToClear);

#undef traceEVENT_GROUP_SET_BITS
#define traceEVENT_GROUP_SET_BITS(eg, bitsToSet)                                                                       \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask)                                               \
			prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SETBITS, (Pointer_UBaseType_t)eg, bitsToSet);

#undef traceEVENT_GROUP_SET_BITS_FROM_ISR
#define traceEVENT_GROUP_SET_BITS_FROM_ISR(eg, bitsToSet)                                                              \
	if (TRACE_GET_OBJECT_FILTER(EVENTGROUP, eg) & CurrentFilterMask)                                                   \
		prvTraceStoreEvent2(PSF_EVENT_EVENTGROUP_SETBITS_FROMISR, (uint32_t)eg, bitsToSet);

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS == 1) */

#if (TRC_CFG_SCHEDULING_ONLY == 0)

#undef traceTASK_NOTIFY_TAKE
#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0)
#define traceTASK_NOTIFY_TAKE()                                                                                        \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) {                                         \
		if (pxCurrentTCB->ucNotifyState == taskNOTIFICATION_RECEIVED)                                                  \
			prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE, (Pointer_UBaseType_t)pxCurrentTCB, xTicksToWait);          \
		else                                                                                                           \
			prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_FAILED, (Pointer_UBaseType_t)pxCurrentTCB, xTicksToWait);   \
	}
#else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */
#define traceTASK_NOTIFY_TAKE()                                                                                        \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) {                                         \
		if (pxCurrentTCB->eNotifyState == eNotified)                                                                   \
			prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE, (uint32_t)pxCurrentTCB, xTicksToWait);                     \
		else                                                                                                           \
			prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait);              \
	}
#endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */

#undef traceTASK_NOTIFY_TAKE_BLOCK
#define traceTASK_NOTIFY_TAKE_BLOCK()                                                                                  \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_TAKE_BLOCK, (Pointer_UBaseType_t)pxCurrentTCB, xTicksToWait);

#undef traceTASK_NOTIFY_WAIT
#if (TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0)
#define traceTASK_NOTIFY_WAIT()                                                                                        \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) {                                         \
		if (pxCurrentTCB->ucNotifyState == taskNOTIFICATION_RECEIVED)                                                  \
			prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT, (Pointer_UBaseType_t)pxCurrentTCB, xTicksToWait);          \
		else                                                                                                           \
			prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (Pointer_UBaseType_t)pxCurrentTCB, xTicksToWait);   \
	}
#else /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */
#define traceTASK_NOTIFY_WAIT()                                                                                        \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) {                                         \
		if (pxCurrentTCB->eNotifyState == eNotified)                                                                   \
			prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT, (uint32_t)pxCurrentTCB, xTicksToWait);                     \
		else                                                                                                           \
			prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_FAILED, (uint32_t)pxCurrentTCB, xTicksToWait);              \
	}
#endif /* TRC_CFG_FREERTOS_VERSION >= TRC_FREERTOS_VERSION_9_0_0 */

#undef traceTASK_NOTIFY_WAIT_BLOCK
#define traceTASK_NOTIFY_WAIT_BLOCK()                                                                                  \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreEvent2(PSF_EVENT_TASK_NOTIFY_WAIT_BLOCK, (Pointer_UBaseType_t)pxCurrentTCB, xTicksToWait);

#undef traceTASK_NOTIFY
#define traceTASK_NOTIFY()                                                                                             \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		prvTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY, (Pointer_UBaseType_t)xTaskToNotify);

#undef traceTASK_NOTIFY_FROM_ISR
#define traceTASK_NOTIFY_FROM_ISR()                                                                                    \
	prvTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY_FROM_ISR, (Pointer_UBaseType_t)xTaskToNotify);

#undef traceTASK_NOTIFY_GIVE_FROM_ISR
#define traceTASK_NOTIFY_GIVE_FROM_ISR()                                                                               \
	prvTraceStoreEvent1(PSF_EVENT_TASK_NOTIFY_GIVE_FROM_ISR, (Pointer_UBaseType_t)xTaskToNotify);

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) */

#undef traceQUEUE_REGISTRY_ADD
#define traceQUEUE_REGISTRY_ADD(object, name)                                                                          \
	prvTraceSaveSymbol(object, (const char *)name);                                                                    \
	prvTraceStoreStringEvent(1, PSF_EVENT_OBJ_NAME, name, object);

#if (TRC_CFG_SCHEDULING_ONLY == 0)
#undef traceSTREAM_BUFFER_CREATE
#define traceSTREAM_BUFFER_CREATE(pxStreamBuffer, xIsMessageBuffer)                                                    \
	TRACE_SET_OBJECT_FILTER(STREAMBUFFER, pxStreamBuffer, CurrentFilterGroup);                                         \
	prvTraceStoreEvent2(xIsMessageBuffer == 1 ? PSF_EVENT_MESSAGEBUFFER_CREATE : PSF_EVENT_STREAMBUFFER_CREATE,        \
	                    (Pointer_UBaseType_t)pxStreamBuffer,                                                                      \
	                    xBufferSizeBytes);

#undef traceSTREAM_BUFFER_CREATE_FAILED
#define traceSTREAM_BUFFER_CREATE_FAILED(xIsMessageBuffer)                                                             \
	prvTraceStoreEvent2(xIsMessageBuffer == 1 ? PSF_EVENT_MESSAGEBUFFER_CREATE_FAILED                                  \
	                                          : PSF_EVENT_STREAMBUFFER_CREATE_FAILED,                                  \
	                    0,                                                                                             \
	                    xBufferSizeBytes);

#undef traceSTREAM_BUFFER_CREATE_STATIC_FAILED
#define traceSTREAM_BUFFER_CREATE_STATIC_FAILED(xReturn, xIsMessageBuffer)                                             \
	traceSTREAM_BUFFER_CREATE_FAILED(xIsMessageBuffer)

#undef traceSTREAM_BUFFER_DELETE
#define traceSTREAM_BUFFER_DELETE(xStreamBuffer)                                                                       \
	prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_DELETE                     \
	                                                              : PSF_EVENT_STREAMBUFFER_DELETE,                     \
	                    (Pointer_UBaseType_t)xStreamBuffer,                                                                       \
	                    prvBytesInBuffer(xStreamBuffer));                                                              \
	prvTraceDeleteSymbol(xStreamBuffer);

#undef traceSTREAM_BUFFER_RESET
#define traceSTREAM_BUFFER_RESET(xStreamBuffer)                                                                        \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask)                                  \
			prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RESET              \
			                                                              : PSF_EVENT_STREAMBUFFER_RESET,              \
			                    (Pointer_UBaseType_t)xStreamBuffer,                                                               \
			                    0);

#undef traceSTREAM_BUFFER_SEND
#define traceSTREAM_BUFFER_SEND(xStreamBuffer, xReturn)                                                                \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask)                                  \
			prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND               \
			                                                              : PSF_EVENT_STREAMBUFFER_SEND,               \
			                    (Pointer_UBaseType_t)xStreamBuffer,                                                               \
			                    prvBytesInBuffer(xStreamBuffer));

#undef traceBLOCKING_ON_STREAM_BUFFER_SEND
#define traceBLOCKING_ON_STREAM_BUFFER_SEND(xStreamBuffer)                                                             \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask)                                  \
			prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_BLOCK         \
			                                                              : PSF_EVENT_STREAMBUFFER_SEND_BLOCK,         \
			                    (Pointer_UBaseType_t)xStreamBuffer);

#undef traceSTREAM_BUFFER_SEND_FAILED
#define traceSTREAM_BUFFER_SEND_FAILED(xStreamBuffer)                                                                  \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask)                                  \
			prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_FAILED        \
			                                                              : PSF_EVENT_STREAMBUFFER_SEND_FAILED,        \
			                    (Pointer_UBaseType_t)xStreamBuffer);

#undef traceSTREAM_BUFFER_RECEIVE
#define traceSTREAM_BUFFER_RECEIVE(xStreamBuffer, xReceivedLength)                                                     \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask)                                  \
			prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE            \
			                                                              : PSF_EVENT_STREAMBUFFER_RECEIVE,            \
			                    (Pointer_UBaseType_t)xStreamBuffer,                                                               \
			                    prvBytesInBuffer(xStreamBuffer));

#undef traceBLOCKING_ON_STREAM_BUFFER_RECEIVE
#define traceBLOCKING_ON_STREAM_BUFFER_RECEIVE(xStreamBuffer)                                                          \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask)                                  \
			prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_BLOCK      \
			                                                              : PSF_EVENT_STREAMBUFFER_RECEIVE_BLOCK,      \
			                    (Pointer_UBaseType_t)xStreamBuffer);

#undef traceSTREAM_BUFFER_RECEIVE_FAILED
#define traceSTREAM_BUFFER_RECEIVE_FAILED(xStreamBuffer)                                                               \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask)                                           \
		if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask)                                  \
			prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_FAILED     \
			                                                              : PSF_EVENT_STREAMBUFFER_RECEIVE_FAILED,     \
			                    (Pointer_UBaseType_t)xStreamBuffer);

#undef traceSTREAM_BUFFER_SEND_FROM_ISR
#define traceSTREAM_BUFFER_SEND_FROM_ISR(xStreamBuffer, xReturn)                                                       \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) {                                         \
		if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) {                                \
			if (xReturn > (size_t)0) {                                                                                 \
				prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0 ? PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR  \
				                                                              : PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR,  \
				                    (Pointer_UBaseType_t)xStreamBuffer,                                                           \
				                    prvBytesInBuffer(xStreamBuffer));                                                  \
			} else {                                                                                                   \
				prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0                                          \
				                        ? PSF_EVENT_MESSAGEBUFFER_SEND_FROM_ISR_FAILED                                 \
				                        : PSF_EVENT_STREAMBUFFER_SEND_FROM_ISR_FAILED,                                 \
				                    (Pointer_UBaseType_t)xStreamBuffer);                                                          \
			}                                                                                                          \
		}                                                                                                              \
	}


#undef traceSTREAM_BUFFER_RECEIVE_FROM_ISR
#define traceSTREAM_BUFFER_RECEIVE_FROM_ISR(xStreamBuffer, xReceivedLength)                                            \
	if (TRACE_GET_TASK_FILTER(TRACE_GET_CURRENT_TASK()) & CurrentFilterMask) {                                         \
		if (TRACE_GET_OBJECT_FILTER(STREAMBUFFER, xStreamBuffer) & CurrentFilterMask) {                                \
			if (xReceivedLength > (size_t)0) {                                                                         \
				prvTraceStoreEvent2(prvGetStreamBufferType(xStreamBuffer) > 0                                          \
				                        ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR                                     \
				                        : PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR,                                     \
				                    (Pointer_UBaseType_t)xStreamBuffer,                                                           \
				                    prvBytesInBuffer(xStreamBuffer));                                                  \
			} else {                                                                                                   \
				prvTraceStoreEvent1(prvGetStreamBufferType(xStreamBuffer) > 0                                          \
				                        ? PSF_EVENT_MESSAGEBUFFER_RECEIVE_FROM_ISR_FAILED                              \
				                        : PSF_EVENT_STREAMBUFFER_RECEIVE_FROM_ISR_FAILED,                              \
				                    (Pointer_UBaseType_t)xStreamBuffer);                                                          \
			}                                                                                                          \
		}                                                                                                              \
	}

#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) */

#endif /* (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING) */

#else /* (TRC_USE_TRACEALYZER_RECORDER == 1) */

/* When recorder is disabled */
#define vTraceSetQueueName(object, name)
#define vTraceSetSemaphoreName(object, name)
#define vTraceSetMutexName(object, name)
#define vTraceSetEventGroupName(object, name)
#define vTraceSetStreamBufferName(object, name)
#define vTraceSetMessageBufferName(object, name)

#endif /* (TRC_USE_TRACEALYZER_RECORDER == 1) */

#ifdef __cplusplus
}
#endif

#endif /* TRC_KERNEL_PORT_H */
